package org.eclipse.ocl.xtext.essentialocl.ui.contentassist.antlr.internal;

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ui.editor.contentassist.antlr.internal.DFA;
import org.eclipse.ocl.xtext.essentialocl.services.EssentialOCLGrammarAccess;


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
/*******************************************************************************
 * Copyright (c) 2011, 2021 Willink Transformations and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     E.D.Willink - initial API and implementation
 *******************************************************************************/
@SuppressWarnings("all")
public class InternalEssentialOCLParser extends AbstractInternalContentAssistParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_SINGLE_QUOTED_STRING", "RULE_SIMPLE_ID", "RULE_ESCAPED_ID", "RULE_ESCAPED_CHARACTER", "RULE_LETTER_CHARACTER", "RULE_DOUBLE_QUOTED_STRING", "RULE_ML_SINGLE_QUOTED_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'-'", "'not'", "'not2'", "'*'", "'/'", "'+'", "'>'", "'<'", "'>='", "'<='", "'='", "'<>'", "'and'", "'and2'", "'implies'", "'implies2'", "'or'", "'or2'", "'xor'", "'xor2'", "'.'", "'->'", "'?.'", "'?->'", "'Map'", "'Tuple'", "'Boolean'", "'Integer'", "'Real'", "'String'", "'UnlimitedNatural'", "'OclAny'", "'OclInvalid'", "'OclVoid'", "'Set'", "'Bag'", "'Sequence'", "'Collection'", "'OrderedSet'", "'with'", "'<-'", "'|?'", "'?'", "'('", "')'", "','", "':'", "'{'", "'}'", "'..'", "'++'", "'Lambda'", "'invalid'", "'null'", "'pre'", "'['", "']'", "'in'", "'if'", "'then'", "'else'", "'endif'", "'elseif'", "'let'", "'self'", "'::'", "'extends'", "'&&'", "'true'", "'false'", "'@'", "'|'", "';'", "'|1'"
    };
    public static final int T__50=50;
    public static final int RULE_LETTER_CHARACTER=9;
    public static final int T__19=19;
    public static final int T__59=59;
    public static final int T__16=16;
    public static final int T__17=17;
    public static final int T__18=18;
    public static final int T__55=55;
    public static final int RULE_ESCAPED_CHARACTER=8;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int RULE_ML_SINGLE_QUOTED_STRING=11;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int T__60=60;
    public static final int T__61=61;
    public static final int T__26=26;
    public static final int T__27=27;
    public static final int T__28=28;
    public static final int RULE_INT=4;
    public static final int T__29=29;
    public static final int T__22=22;
    public static final int T__66=66;
    public static final int RULE_ML_COMMENT=12;
    public static final int T__23=23;
    public static final int T__67=67;
    public static final int T__24=24;
    public static final int T__68=68;
    public static final int T__25=25;
    public static final int T__69=69;
    public static final int T__62=62;
    public static final int T__63=63;
    public static final int T__20=20;
    public static final int T__64=64;
    public static final int T__21=21;
    public static final int T__65=65;
    public static final int T__70=70;
    public static final int T__71=71;
    public static final int T__72=72;
    public static final int RULE_SL_COMMENT=13;
    public static final int T__37=37;
    public static final int T__38=38;
    public static final int T__39=39;
    public static final int T__33=33;
    public static final int T__77=77;
    public static final int T__34=34;
    public static final int T__78=78;
    public static final int T__35=35;
    public static final int T__79=79;
    public static final int T__36=36;
    public static final int T__73=73;
    public static final int EOF=-1;
    public static final int T__30=30;
    public static final int T__74=74;
    public static final int T__31=31;
    public static final int T__75=75;
    public static final int T__32=32;
    public static final int T__76=76;
    public static final int T__80=80;
    public static final int T__81=81;
    public static final int T__82=82;
    public static final int RULE_SIMPLE_ID=6;
    public static final int T__83=83;
    public static final int RULE_WS=14;
    public static final int RULE_ANY_OTHER=15;
    public static final int RULE_SINGLE_QUOTED_STRING=5;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int RULE_DOUBLE_QUOTED_STRING=10;
    public static final int T__44=44;
    public static final int T__88=88;
    public static final int T__45=45;
    public static final int T__89=89;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int RULE_ESCAPED_ID=7;
    public static final int T__40=40;
    public static final int T__84=84;
    public static final int T__41=41;
    public static final int T__85=85;
    public static final int T__42=42;
    public static final int T__86=86;
    public static final int T__43=43;
    public static final int T__87=87;

    // delegates
    // delegators


        public InternalEssentialOCLParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public InternalEssentialOCLParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);

        }


    public String[] getTokenNames() { return InternalEssentialOCLParser.tokenNames; }
    public String getGrammarFileName() { return "InternalEssentialOCL.g"; }


     	private EssentialOCLGrammarAccess grammarAccess;

        public void setGrammarAccess(EssentialOCLGrammarAccess grammarAccess) {
        	this.grammarAccess = grammarAccess;
        }

        @Override
        protected Grammar getGrammar() {
        	return grammarAccess.getGrammar();
        }

        @Override
        protected String getValueForTokenName(String tokenName) {
        	return tokenName;
        }


    // $ANTLR start "entryRuleModel"
    // InternalEssentialOCL.g:68:1: entryRuleModel : ruleModel EOF ;
    public final void entryRuleModel() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:69:1: ( ruleModel EOF )
            // InternalEssentialOCL.g:70:1: ruleModel EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleModel();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getModelRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleModel"


    // $ANTLR start "ruleModel"
    // InternalEssentialOCL.g:77:1: ruleModel : ( ( rule__Model__OwnedExpressionAssignment ) ) ;
    public final void ruleModel() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:81:2: ( ( ( rule__Model__OwnedExpressionAssignment ) ) )
            // InternalEssentialOCL.g:82:1: ( ( rule__Model__OwnedExpressionAssignment ) )
            {
            // InternalEssentialOCL.g:82:1: ( ( rule__Model__OwnedExpressionAssignment ) )
            // InternalEssentialOCL.g:83:1: ( rule__Model__OwnedExpressionAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelAccess().getOwnedExpressionAssignment());
            }
            // InternalEssentialOCL.g:84:1: ( rule__Model__OwnedExpressionAssignment )
            // InternalEssentialOCL.g:84:2: rule__Model__OwnedExpressionAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__Model__OwnedExpressionAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getModelAccess().getOwnedExpressionAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleModel"


    // $ANTLR start "entryRuleEssentialOCLUnaryOperatorName"
    // InternalEssentialOCL.g:98:1: entryRuleEssentialOCLUnaryOperatorName : ruleEssentialOCLUnaryOperatorName EOF ;
    public final void entryRuleEssentialOCLUnaryOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:99:1: ( ruleEssentialOCLUnaryOperatorName EOF )
            // InternalEssentialOCL.g:100:1: ruleEssentialOCLUnaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnaryOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEssentialOCLUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnaryOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleEssentialOCLUnaryOperatorName"


    // $ANTLR start "ruleEssentialOCLUnaryOperatorName"
    // InternalEssentialOCL.g:107:1: ruleEssentialOCLUnaryOperatorName : ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) ;
    public final void ruleEssentialOCLUnaryOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:111:2: ( ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) )
            // InternalEssentialOCL.g:112:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            {
            // InternalEssentialOCL.g:112:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            // InternalEssentialOCL.g:113:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:114:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            // InternalEssentialOCL.g:114:2: rule__EssentialOCLUnaryOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLUnaryOperatorName__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleEssentialOCLUnaryOperatorName"


    // $ANTLR start "entryRuleEssentialOCLInfixOperatorName"
    // InternalEssentialOCL.g:126:1: entryRuleEssentialOCLInfixOperatorName : ruleEssentialOCLInfixOperatorName EOF ;
    public final void entryRuleEssentialOCLInfixOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:127:1: ( ruleEssentialOCLInfixOperatorName EOF )
            // InternalEssentialOCL.g:128:1: ruleEssentialOCLInfixOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLInfixOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEssentialOCLInfixOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLInfixOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleEssentialOCLInfixOperatorName"


    // $ANTLR start "ruleEssentialOCLInfixOperatorName"
    // InternalEssentialOCL.g:135:1: ruleEssentialOCLInfixOperatorName : ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) ;
    public final void ruleEssentialOCLInfixOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:139:2: ( ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) )
            // InternalEssentialOCL.g:140:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            {
            // InternalEssentialOCL.g:140:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            // InternalEssentialOCL.g:141:1: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:142:1: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            // InternalEssentialOCL.g:142:2: rule__EssentialOCLInfixOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLInfixOperatorName__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleEssentialOCLInfixOperatorName"


    // $ANTLR start "entryRuleEssentialOCLNavigationOperatorName"
    // InternalEssentialOCL.g:154:1: entryRuleEssentialOCLNavigationOperatorName : ruleEssentialOCLNavigationOperatorName EOF ;
    public final void entryRuleEssentialOCLNavigationOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:155:1: ( ruleEssentialOCLNavigationOperatorName EOF )
            // InternalEssentialOCL.g:156:1: ruleEssentialOCLNavigationOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLNavigationOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEssentialOCLNavigationOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLNavigationOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleEssentialOCLNavigationOperatorName"


    // $ANTLR start "ruleEssentialOCLNavigationOperatorName"
    // InternalEssentialOCL.g:163:1: ruleEssentialOCLNavigationOperatorName : ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) ;
    public final void ruleEssentialOCLNavigationOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:167:2: ( ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) )
            // InternalEssentialOCL.g:168:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            {
            // InternalEssentialOCL.g:168:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            // InternalEssentialOCL.g:169:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:170:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            // InternalEssentialOCL.g:170:2: rule__EssentialOCLNavigationOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLNavigationOperatorName__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleEssentialOCLNavigationOperatorName"


    // $ANTLR start "entryRuleBinaryOperatorName"
    // InternalEssentialOCL.g:182:1: entryRuleBinaryOperatorName : ruleBinaryOperatorName EOF ;
    public final void entryRuleBinaryOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:183:1: ( ruleBinaryOperatorName EOF )
            // InternalEssentialOCL.g:184:1: ruleBinaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBinaryOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleBinaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBinaryOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleBinaryOperatorName"


    // $ANTLR start "ruleBinaryOperatorName"
    // InternalEssentialOCL.g:191:1: ruleBinaryOperatorName : ( ( rule__BinaryOperatorName__Alternatives ) ) ;
    public final void ruleBinaryOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:195:2: ( ( ( rule__BinaryOperatorName__Alternatives ) ) )
            // InternalEssentialOCL.g:196:1: ( ( rule__BinaryOperatorName__Alternatives ) )
            {
            // InternalEssentialOCL.g:196:1: ( ( rule__BinaryOperatorName__Alternatives ) )
            // InternalEssentialOCL.g:197:1: ( rule__BinaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBinaryOperatorNameAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:198:1: ( rule__BinaryOperatorName__Alternatives )
            // InternalEssentialOCL.g:198:2: rule__BinaryOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__BinaryOperatorName__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBinaryOperatorNameAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleBinaryOperatorName"


    // $ANTLR start "entryRuleInfixOperatorName"
    // InternalEssentialOCL.g:210:1: entryRuleInfixOperatorName : ruleInfixOperatorName EOF ;
    public final void entryRuleInfixOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:211:1: ( ruleInfixOperatorName EOF )
            // InternalEssentialOCL.g:212:1: ruleInfixOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInfixOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleInfixOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInfixOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleInfixOperatorName"


    // $ANTLR start "ruleInfixOperatorName"
    // InternalEssentialOCL.g:219:1: ruleInfixOperatorName : ( ruleEssentialOCLInfixOperatorName ) ;
    public final void ruleInfixOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:223:2: ( ( ruleEssentialOCLInfixOperatorName ) )
            // InternalEssentialOCL.g:224:1: ( ruleEssentialOCLInfixOperatorName )
            {
            // InternalEssentialOCL.g:224:1: ( ruleEssentialOCLInfixOperatorName )
            // InternalEssentialOCL.g:225:1: ruleEssentialOCLInfixOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLInfixOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleInfixOperatorName"


    // $ANTLR start "entryRuleNavigationOperatorName"
    // InternalEssentialOCL.g:238:1: entryRuleNavigationOperatorName : ruleNavigationOperatorName EOF ;
    public final void entryRuleNavigationOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:239:1: ( ruleNavigationOperatorName EOF )
            // InternalEssentialOCL.g:240:1: ruleNavigationOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigationOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigationOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigationOperatorName"


    // $ANTLR start "ruleNavigationOperatorName"
    // InternalEssentialOCL.g:247:1: ruleNavigationOperatorName : ( ruleEssentialOCLNavigationOperatorName ) ;
    public final void ruleNavigationOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:251:2: ( ( ruleEssentialOCLNavigationOperatorName ) )
            // InternalEssentialOCL.g:252:1: ( ruleEssentialOCLNavigationOperatorName )
            {
            // InternalEssentialOCL.g:252:1: ( ruleEssentialOCLNavigationOperatorName )
            // InternalEssentialOCL.g:253:1: ruleEssentialOCLNavigationOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLNavigationOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigationOperatorName"


    // $ANTLR start "entryRuleUnaryOperatorName"
    // InternalEssentialOCL.g:266:1: entryRuleUnaryOperatorName : ruleUnaryOperatorName EOF ;
    public final void entryRuleUnaryOperatorName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:267:1: ( ruleUnaryOperatorName EOF )
            // InternalEssentialOCL.g:268:1: ruleUnaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnaryOperatorNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnaryOperatorNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUnaryOperatorName"


    // $ANTLR start "ruleUnaryOperatorName"
    // InternalEssentialOCL.g:275:1: ruleUnaryOperatorName : ( ruleEssentialOCLUnaryOperatorName ) ;
    public final void ruleUnaryOperatorName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:279:2: ( ( ruleEssentialOCLUnaryOperatorName ) )
            // InternalEssentialOCL.g:280:1: ( ruleEssentialOCLUnaryOperatorName )
            {
            // InternalEssentialOCL.g:280:1: ( ruleEssentialOCLUnaryOperatorName )
            // InternalEssentialOCL.g:281:1: ruleEssentialOCLUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUnaryOperatorName"


    // $ANTLR start "entryRuleEssentialOCLUnrestrictedName"
    // InternalEssentialOCL.g:294:1: entryRuleEssentialOCLUnrestrictedName : ruleEssentialOCLUnrestrictedName EOF ;
    public final void entryRuleEssentialOCLUnrestrictedName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:295:1: ( ruleEssentialOCLUnrestrictedName EOF )
            // InternalEssentialOCL.g:296:1: ruleEssentialOCLUnrestrictedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnrestrictedNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEssentialOCLUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnrestrictedNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleEssentialOCLUnrestrictedName"


    // $ANTLR start "ruleEssentialOCLUnrestrictedName"
    // InternalEssentialOCL.g:303:1: ruleEssentialOCLUnrestrictedName : ( ruleIdentifier ) ;
    public final void ruleEssentialOCLUnrestrictedName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:307:2: ( ( ruleIdentifier ) )
            // InternalEssentialOCL.g:308:1: ( ruleIdentifier )
            {
            // InternalEssentialOCL.g:308:1: ( ruleIdentifier )
            // InternalEssentialOCL.g:309:1: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleEssentialOCLUnrestrictedName"


    // $ANTLR start "entryRuleUnrestrictedName"
    // InternalEssentialOCL.g:322:1: entryRuleUnrestrictedName : ruleUnrestrictedName EOF ;
    public final void entryRuleUnrestrictedName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:323:1: ( ruleUnrestrictedName EOF )
            // InternalEssentialOCL.g:324:1: ruleUnrestrictedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnrestrictedNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnrestrictedNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUnrestrictedName"


    // $ANTLR start "ruleUnrestrictedName"
    // InternalEssentialOCL.g:331:1: ruleUnrestrictedName : ( ruleEssentialOCLUnrestrictedName ) ;
    public final void ruleUnrestrictedName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:335:2: ( ( ruleEssentialOCLUnrestrictedName ) )
            // InternalEssentialOCL.g:336:1: ( ruleEssentialOCLUnrestrictedName )
            {
            // InternalEssentialOCL.g:336:1: ( ruleEssentialOCLUnrestrictedName )
            // InternalEssentialOCL.g:337:1: ruleEssentialOCLUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUnrestrictedName"


    // $ANTLR start "entryRuleEssentialOCLUnreservedName"
    // InternalEssentialOCL.g:350:1: entryRuleEssentialOCLUnreservedName : ruleEssentialOCLUnreservedName EOF ;
    public final void entryRuleEssentialOCLUnreservedName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:351:1: ( ruleEssentialOCLUnreservedName EOF )
            // InternalEssentialOCL.g:352:1: ruleEssentialOCLUnreservedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnreservedNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEssentialOCLUnreservedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnreservedNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleEssentialOCLUnreservedName"


    // $ANTLR start "ruleEssentialOCLUnreservedName"
    // InternalEssentialOCL.g:359:1: ruleEssentialOCLUnreservedName : ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) ;
    public final void ruleEssentialOCLUnreservedName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:363:2: ( ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) )
            // InternalEssentialOCL.g:364:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            {
            // InternalEssentialOCL.g:364:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            // InternalEssentialOCL.g:365:1: ( rule__EssentialOCLUnreservedName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:366:1: ( rule__EssentialOCLUnreservedName__Alternatives )
            // InternalEssentialOCL.g:366:2: rule__EssentialOCLUnreservedName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLUnreservedName__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleEssentialOCLUnreservedName"


    // $ANTLR start "entryRuleUnreservedName"
    // InternalEssentialOCL.g:378:1: entryRuleUnreservedName : ruleUnreservedName EOF ;
    public final void entryRuleUnreservedName() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:379:1: ( ruleUnreservedName EOF )
            // InternalEssentialOCL.g:380:1: ruleUnreservedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnreservedNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUnreservedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnreservedNameRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUnreservedName"


    // $ANTLR start "ruleUnreservedName"
    // InternalEssentialOCL.g:387:1: ruleUnreservedName : ( ruleEssentialOCLUnreservedName ) ;
    public final void ruleUnreservedName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:391:2: ( ( ruleEssentialOCLUnreservedName ) )
            // InternalEssentialOCL.g:392:1: ( ruleEssentialOCLUnreservedName )
            {
            // InternalEssentialOCL.g:392:1: ( ruleEssentialOCLUnreservedName )
            // InternalEssentialOCL.g:393:1: ruleEssentialOCLUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnreservedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUnreservedName"


    // $ANTLR start "entryRuleURIFirstPathElementCS"
    // InternalEssentialOCL.g:408:1: entryRuleURIFirstPathElementCS : ruleURIFirstPathElementCS EOF ;
    public final void entryRuleURIFirstPathElementCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:409:1: ( ruleURIFirstPathElementCS EOF )
            // InternalEssentialOCL.g:410:1: ruleURIFirstPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleURIFirstPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleURIFirstPathElementCS"


    // $ANTLR start "ruleURIFirstPathElementCS"
    // InternalEssentialOCL.g:417:1: ruleURIFirstPathElementCS : ( ( rule__URIFirstPathElementCS__Alternatives ) ) ;
    public final void ruleURIFirstPathElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:421:2: ( ( ( rule__URIFirstPathElementCS__Alternatives ) ) )
            // InternalEssentialOCL.g:422:1: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:422:1: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            // InternalEssentialOCL.g:423:1: ( rule__URIFirstPathElementCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:424:1: ( rule__URIFirstPathElementCS__Alternatives )
            // InternalEssentialOCL.g:424:2: rule__URIFirstPathElementCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleURIFirstPathElementCS"


    // $ANTLR start "entryRulePrimitiveTypeIdentifier"
    // InternalEssentialOCL.g:438:1: entryRulePrimitiveTypeIdentifier : rulePrimitiveTypeIdentifier EOF ;
    public final void entryRulePrimitiveTypeIdentifier() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:439:1: ( rulePrimitiveTypeIdentifier EOF )
            // InternalEssentialOCL.g:440:1: rulePrimitiveTypeIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeIdentifierRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrimitiveTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeIdentifierRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimitiveTypeIdentifier"


    // $ANTLR start "rulePrimitiveTypeIdentifier"
    // InternalEssentialOCL.g:447:1: rulePrimitiveTypeIdentifier : ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) ;
    public final void rulePrimitiveTypeIdentifier() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:451:2: ( ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) )
            // InternalEssentialOCL.g:452:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            {
            // InternalEssentialOCL.g:452:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            // InternalEssentialOCL.g:453:1: ( rule__PrimitiveTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:454:1: ( rule__PrimitiveTypeIdentifier__Alternatives )
            // InternalEssentialOCL.g:454:2: rule__PrimitiveTypeIdentifier__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveTypeIdentifier__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimitiveTypeIdentifier"


    // $ANTLR start "entryRulePrimitiveTypeCS"
    // InternalEssentialOCL.g:466:1: entryRulePrimitiveTypeCS : rulePrimitiveTypeCS EOF ;
    public final void entryRulePrimitiveTypeCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:467:1: ( rulePrimitiveTypeCS EOF )
            // InternalEssentialOCL.g:468:1: rulePrimitiveTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrimitiveTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimitiveTypeCS"


    // $ANTLR start "rulePrimitiveTypeCS"
    // InternalEssentialOCL.g:475:1: rulePrimitiveTypeCS : ( ( rule__PrimitiveTypeCS__NameAssignment ) ) ;
    public final void rulePrimitiveTypeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:479:2: ( ( ( rule__PrimitiveTypeCS__NameAssignment ) ) )
            // InternalEssentialOCL.g:480:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            {
            // InternalEssentialOCL.g:480:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            // InternalEssentialOCL.g:481:1: ( rule__PrimitiveTypeCS__NameAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment());
            }
            // InternalEssentialOCL.g:482:1: ( rule__PrimitiveTypeCS__NameAssignment )
            // InternalEssentialOCL.g:482:2: rule__PrimitiveTypeCS__NameAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveTypeCS__NameAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimitiveTypeCS"


    // $ANTLR start "entryRuleCollectionTypeIdentifier"
    // InternalEssentialOCL.g:494:1: entryRuleCollectionTypeIdentifier : ruleCollectionTypeIdentifier EOF ;
    public final void entryRuleCollectionTypeIdentifier() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:495:1: ( ruleCollectionTypeIdentifier EOF )
            // InternalEssentialOCL.g:496:1: ruleCollectionTypeIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeIdentifierRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCollectionTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeIdentifierRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCollectionTypeIdentifier"


    // $ANTLR start "ruleCollectionTypeIdentifier"
    // InternalEssentialOCL.g:503:1: ruleCollectionTypeIdentifier : ( ( rule__CollectionTypeIdentifier__Alternatives ) ) ;
    public final void ruleCollectionTypeIdentifier() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:507:2: ( ( ( rule__CollectionTypeIdentifier__Alternatives ) ) )
            // InternalEssentialOCL.g:508:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            {
            // InternalEssentialOCL.g:508:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            // InternalEssentialOCL.g:509:1: ( rule__CollectionTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:510:1: ( rule__CollectionTypeIdentifier__Alternatives )
            // InternalEssentialOCL.g:510:2: rule__CollectionTypeIdentifier__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeIdentifier__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCollectionTypeIdentifier"


    // $ANTLR start "entryRuleCollectionTypeCS"
    // InternalEssentialOCL.g:522:1: entryRuleCollectionTypeCS : ruleCollectionTypeCS EOF ;
    public final void entryRuleCollectionTypeCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:523:1: ( ruleCollectionTypeCS EOF )
            // InternalEssentialOCL.g:524:1: ruleCollectionTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCollectionTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCollectionTypeCS"


    // $ANTLR start "ruleCollectionTypeCS"
    // InternalEssentialOCL.g:531:1: ruleCollectionTypeCS : ( ( rule__CollectionTypeCS__Group__0 ) ) ;
    public final void ruleCollectionTypeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:535:2: ( ( ( rule__CollectionTypeCS__Group__0 ) ) )
            // InternalEssentialOCL.g:536:1: ( ( rule__CollectionTypeCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:536:1: ( ( rule__CollectionTypeCS__Group__0 ) )
            // InternalEssentialOCL.g:537:1: ( rule__CollectionTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:538:1: ( rule__CollectionTypeCS__Group__0 )
            // InternalEssentialOCL.g:538:2: rule__CollectionTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCollectionTypeCS"


    // $ANTLR start "entryRuleMapTypeCS"
    // InternalEssentialOCL.g:550:1: entryRuleMapTypeCS : ruleMapTypeCS EOF ;
    public final void entryRuleMapTypeCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:551:1: ( ruleMapTypeCS EOF )
            // InternalEssentialOCL.g:552:1: ruleMapTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMapTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMapTypeCS"


    // $ANTLR start "ruleMapTypeCS"
    // InternalEssentialOCL.g:559:1: ruleMapTypeCS : ( ( rule__MapTypeCS__Group__0 ) ) ;
    public final void ruleMapTypeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:563:2: ( ( ( rule__MapTypeCS__Group__0 ) ) )
            // InternalEssentialOCL.g:564:1: ( ( rule__MapTypeCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:564:1: ( ( rule__MapTypeCS__Group__0 ) )
            // InternalEssentialOCL.g:565:1: ( rule__MapTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:566:1: ( rule__MapTypeCS__Group__0 )
            // InternalEssentialOCL.g:566:2: rule__MapTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMapTypeCS"


    // $ANTLR start "entryRuleTupleTypeCS"
    // InternalEssentialOCL.g:578:1: entryRuleTupleTypeCS : ruleTupleTypeCS EOF ;
    public final void entryRuleTupleTypeCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:579:1: ( ruleTupleTypeCS EOF )
            // InternalEssentialOCL.g:580:1: ruleTupleTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTupleTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTupleTypeCS"


    // $ANTLR start "ruleTupleTypeCS"
    // InternalEssentialOCL.g:587:1: ruleTupleTypeCS : ( ( rule__TupleTypeCS__Group__0 ) ) ;
    public final void ruleTupleTypeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:591:2: ( ( ( rule__TupleTypeCS__Group__0 ) ) )
            // InternalEssentialOCL.g:592:1: ( ( rule__TupleTypeCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:592:1: ( ( rule__TupleTypeCS__Group__0 ) )
            // InternalEssentialOCL.g:593:1: ( rule__TupleTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:594:1: ( rule__TupleTypeCS__Group__0 )
            // InternalEssentialOCL.g:594:2: rule__TupleTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTupleTypeCS"


    // $ANTLR start "entryRuleTuplePartCS"
    // InternalEssentialOCL.g:606:1: entryRuleTuplePartCS : ruleTuplePartCS EOF ;
    public final void entryRuleTuplePartCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:607:1: ( ruleTuplePartCS EOF )
            // InternalEssentialOCL.g:608:1: ruleTuplePartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTuplePartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTuplePartCS"


    // $ANTLR start "ruleTuplePartCS"
    // InternalEssentialOCL.g:615:1: ruleTuplePartCS : ( ( rule__TuplePartCS__Group__0 ) ) ;
    public final void ruleTuplePartCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:619:2: ( ( ( rule__TuplePartCS__Group__0 ) ) )
            // InternalEssentialOCL.g:620:1: ( ( rule__TuplePartCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:620:1: ( ( rule__TuplePartCS__Group__0 ) )
            // InternalEssentialOCL.g:621:1: ( rule__TuplePartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:622:1: ( rule__TuplePartCS__Group__0 )
            // InternalEssentialOCL.g:622:2: rule__TuplePartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTuplePartCS"


    // $ANTLR start "entryRuleCollectionLiteralExpCS"
    // InternalEssentialOCL.g:634:1: entryRuleCollectionLiteralExpCS : ruleCollectionLiteralExpCS EOF ;
    public final void entryRuleCollectionLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:635:1: ( ruleCollectionLiteralExpCS EOF )
            // InternalEssentialOCL.g:636:1: ruleCollectionLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCollectionLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCollectionLiteralExpCS"


    // $ANTLR start "ruleCollectionLiteralExpCS"
    // InternalEssentialOCL.g:643:1: ruleCollectionLiteralExpCS : ( ( rule__CollectionLiteralExpCS__Group__0 ) ) ;
    public final void ruleCollectionLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:647:2: ( ( ( rule__CollectionLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:648:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:648:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:649:1: ( rule__CollectionLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:650:1: ( rule__CollectionLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:650:2: rule__CollectionLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCollectionLiteralExpCS"


    // $ANTLR start "entryRuleCollectionLiteralPartCS"
    // InternalEssentialOCL.g:662:1: entryRuleCollectionLiteralPartCS : ruleCollectionLiteralPartCS EOF ;
    public final void entryRuleCollectionLiteralPartCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:663:1: ( ruleCollectionLiteralPartCS EOF )
            // InternalEssentialOCL.g:664:1: ruleCollectionLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCollectionLiteralPartCS"


    // $ANTLR start "ruleCollectionLiteralPartCS"
    // InternalEssentialOCL.g:671:1: ruleCollectionLiteralPartCS : ( ( rule__CollectionLiteralPartCS__Alternatives ) ) ;
    public final void ruleCollectionLiteralPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:675:2: ( ( ( rule__CollectionLiteralPartCS__Alternatives ) ) )
            // InternalEssentialOCL.g:676:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:676:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            // InternalEssentialOCL.g:677:1: ( rule__CollectionLiteralPartCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:678:1: ( rule__CollectionLiteralPartCS__Alternatives )
            // InternalEssentialOCL.g:678:2: rule__CollectionLiteralPartCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCollectionLiteralPartCS"


    // $ANTLR start "entryRuleCollectionPatternCS"
    // InternalEssentialOCL.g:690:1: entryRuleCollectionPatternCS : ruleCollectionPatternCS EOF ;
    public final void entryRuleCollectionPatternCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:691:1: ( ruleCollectionPatternCS EOF )
            // InternalEssentialOCL.g:692:1: ruleCollectionPatternCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCollectionPatternCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCollectionPatternCS"


    // $ANTLR start "ruleCollectionPatternCS"
    // InternalEssentialOCL.g:699:1: ruleCollectionPatternCS : ( ( rule__CollectionPatternCS__Group__0 ) ) ;
    public final void ruleCollectionPatternCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:703:2: ( ( ( rule__CollectionPatternCS__Group__0 ) ) )
            // InternalEssentialOCL.g:704:1: ( ( rule__CollectionPatternCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:704:1: ( ( rule__CollectionPatternCS__Group__0 ) )
            // InternalEssentialOCL.g:705:1: ( rule__CollectionPatternCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:706:1: ( rule__CollectionPatternCS__Group__0 )
            // InternalEssentialOCL.g:706:2: rule__CollectionPatternCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCollectionPatternCS"


    // $ANTLR start "entryRuleShadowPartCS"
    // InternalEssentialOCL.g:718:1: entryRuleShadowPartCS : ruleShadowPartCS EOF ;
    public final void entryRuleShadowPartCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:719:1: ( ruleShadowPartCS EOF )
            // InternalEssentialOCL.g:720:1: ruleShadowPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleShadowPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleShadowPartCS"


    // $ANTLR start "ruleShadowPartCS"
    // InternalEssentialOCL.g:727:1: ruleShadowPartCS : ( ( rule__ShadowPartCS__Alternatives ) ) ;
    public final void ruleShadowPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:731:2: ( ( ( rule__ShadowPartCS__Alternatives ) ) )
            // InternalEssentialOCL.g:732:1: ( ( rule__ShadowPartCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:732:1: ( ( rule__ShadowPartCS__Alternatives ) )
            // InternalEssentialOCL.g:733:1: ( rule__ShadowPartCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:734:1: ( rule__ShadowPartCS__Alternatives )
            // InternalEssentialOCL.g:734:2: rule__ShadowPartCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleShadowPartCS"


    // $ANTLR start "entryRulePatternExpCS"
    // InternalEssentialOCL.g:746:1: entryRulePatternExpCS : rulePatternExpCS EOF ;
    public final void entryRulePatternExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:747:1: ( rulePatternExpCS EOF )
            // InternalEssentialOCL.g:748:1: rulePatternExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePatternExpCS"


    // $ANTLR start "rulePatternExpCS"
    // InternalEssentialOCL.g:755:1: rulePatternExpCS : ( ( rule__PatternExpCS__Group__0 ) ) ;
    public final void rulePatternExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:759:2: ( ( ( rule__PatternExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:760:1: ( ( rule__PatternExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:760:1: ( ( rule__PatternExpCS__Group__0 ) )
            // InternalEssentialOCL.g:761:1: ( rule__PatternExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:762:1: ( rule__PatternExpCS__Group__0 )
            // InternalEssentialOCL.g:762:2: rule__PatternExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePatternExpCS"


    // $ANTLR start "entryRuleLambdaLiteralExpCS"
    // InternalEssentialOCL.g:774:1: entryRuleLambdaLiteralExpCS : ruleLambdaLiteralExpCS EOF ;
    public final void entryRuleLambdaLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:775:1: ( ruleLambdaLiteralExpCS EOF )
            // InternalEssentialOCL.g:776:1: ruleLambdaLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleLambdaLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleLambdaLiteralExpCS"


    // $ANTLR start "ruleLambdaLiteralExpCS"
    // InternalEssentialOCL.g:783:1: ruleLambdaLiteralExpCS : ( ( rule__LambdaLiteralExpCS__Group__0 ) ) ;
    public final void ruleLambdaLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:787:2: ( ( ( rule__LambdaLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:788:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:788:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:789:1: ( rule__LambdaLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:790:1: ( rule__LambdaLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:790:2: rule__LambdaLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleLambdaLiteralExpCS"


    // $ANTLR start "entryRuleMapLiteralExpCS"
    // InternalEssentialOCL.g:802:1: entryRuleMapLiteralExpCS : ruleMapLiteralExpCS EOF ;
    public final void entryRuleMapLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:803:1: ( ruleMapLiteralExpCS EOF )
            // InternalEssentialOCL.g:804:1: ruleMapLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMapLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMapLiteralExpCS"


    // $ANTLR start "ruleMapLiteralExpCS"
    // InternalEssentialOCL.g:811:1: ruleMapLiteralExpCS : ( ( rule__MapLiteralExpCS__Group__0 ) ) ;
    public final void ruleMapLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:815:2: ( ( ( rule__MapLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:816:1: ( ( rule__MapLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:816:1: ( ( rule__MapLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:817:1: ( rule__MapLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:818:1: ( rule__MapLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:818:2: rule__MapLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMapLiteralExpCS"


    // $ANTLR start "entryRuleMapLiteralPartCS"
    // InternalEssentialOCL.g:830:1: entryRuleMapLiteralPartCS : ruleMapLiteralPartCS EOF ;
    public final void entryRuleMapLiteralPartCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:831:1: ( ruleMapLiteralPartCS EOF )
            // InternalEssentialOCL.g:832:1: ruleMapLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMapLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMapLiteralPartCS"


    // $ANTLR start "ruleMapLiteralPartCS"
    // InternalEssentialOCL.g:839:1: ruleMapLiteralPartCS : ( ( rule__MapLiteralPartCS__Group__0 ) ) ;
    public final void ruleMapLiteralPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:843:2: ( ( ( rule__MapLiteralPartCS__Group__0 ) ) )
            // InternalEssentialOCL.g:844:1: ( ( rule__MapLiteralPartCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:844:1: ( ( rule__MapLiteralPartCS__Group__0 ) )
            // InternalEssentialOCL.g:845:1: ( rule__MapLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:846:1: ( rule__MapLiteralPartCS__Group__0 )
            // InternalEssentialOCL.g:846:2: rule__MapLiteralPartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMapLiteralPartCS"


    // $ANTLR start "entryRulePrimitiveLiteralExpCS"
    // InternalEssentialOCL.g:858:1: entryRulePrimitiveLiteralExpCS : rulePrimitiveLiteralExpCS EOF ;
    public final void entryRulePrimitiveLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:859:1: ( rulePrimitiveLiteralExpCS EOF )
            // InternalEssentialOCL.g:860:1: rulePrimitiveLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrimitiveLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimitiveLiteralExpCS"


    // $ANTLR start "rulePrimitiveLiteralExpCS"
    // InternalEssentialOCL.g:867:1: rulePrimitiveLiteralExpCS : ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) ;
    public final void rulePrimitiveLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:871:2: ( ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:872:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:872:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            // InternalEssentialOCL.g:873:1: ( rule__PrimitiveLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:874:1: ( rule__PrimitiveLiteralExpCS__Alternatives )
            // InternalEssentialOCL.g:874:2: rule__PrimitiveLiteralExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveLiteralExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimitiveLiteralExpCS"


    // $ANTLR start "entryRuleTupleLiteralExpCS"
    // InternalEssentialOCL.g:886:1: entryRuleTupleLiteralExpCS : ruleTupleLiteralExpCS EOF ;
    public final void entryRuleTupleLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:887:1: ( ruleTupleLiteralExpCS EOF )
            // InternalEssentialOCL.g:888:1: ruleTupleLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTupleLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTupleLiteralExpCS"


    // $ANTLR start "ruleTupleLiteralExpCS"
    // InternalEssentialOCL.g:895:1: ruleTupleLiteralExpCS : ( ( rule__TupleLiteralExpCS__Group__0 ) ) ;
    public final void ruleTupleLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:899:2: ( ( ( rule__TupleLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:900:1: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:900:1: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:901:1: ( rule__TupleLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:902:1: ( rule__TupleLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:902:2: rule__TupleLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTupleLiteralExpCS"


    // $ANTLR start "entryRuleTupleLiteralPartCS"
    // InternalEssentialOCL.g:914:1: entryRuleTupleLiteralPartCS : ruleTupleLiteralPartCS EOF ;
    public final void entryRuleTupleLiteralPartCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:915:1: ( ruleTupleLiteralPartCS EOF )
            // InternalEssentialOCL.g:916:1: ruleTupleLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTupleLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTupleLiteralPartCS"


    // $ANTLR start "ruleTupleLiteralPartCS"
    // InternalEssentialOCL.g:923:1: ruleTupleLiteralPartCS : ( ( rule__TupleLiteralPartCS__Group__0 ) ) ;
    public final void ruleTupleLiteralPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:927:2: ( ( ( rule__TupleLiteralPartCS__Group__0 ) ) )
            // InternalEssentialOCL.g:928:1: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:928:1: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            // InternalEssentialOCL.g:929:1: ( rule__TupleLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:930:1: ( rule__TupleLiteralPartCS__Group__0 )
            // InternalEssentialOCL.g:930:2: rule__TupleLiteralPartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTupleLiteralPartCS"


    // $ANTLR start "entryRuleNumberLiteralExpCS"
    // InternalEssentialOCL.g:942:1: entryRuleNumberLiteralExpCS : ruleNumberLiteralExpCS EOF ;
    public final void entryRuleNumberLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:943:1: ( ruleNumberLiteralExpCS EOF )
            // InternalEssentialOCL.g:944:1: ruleNumberLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNumberLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNumberLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNumberLiteralExpCS"


    // $ANTLR start "ruleNumberLiteralExpCS"
    // InternalEssentialOCL.g:951:1: ruleNumberLiteralExpCS : ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) ;
    public final void ruleNumberLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:955:2: ( ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) )
            // InternalEssentialOCL.g:956:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            {
            // InternalEssentialOCL.g:956:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            // InternalEssentialOCL.g:957:1: ( rule__NumberLiteralExpCS__SymbolAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment());
            }
            // InternalEssentialOCL.g:958:1: ( rule__NumberLiteralExpCS__SymbolAssignment )
            // InternalEssentialOCL.g:958:2: rule__NumberLiteralExpCS__SymbolAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NumberLiteralExpCS__SymbolAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNumberLiteralExpCS"


    // $ANTLR start "entryRuleStringLiteralExpCS"
    // InternalEssentialOCL.g:970:1: entryRuleStringLiteralExpCS : ruleStringLiteralExpCS EOF ;
    public final void entryRuleStringLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:971:1: ( ruleStringLiteralExpCS EOF )
            // InternalEssentialOCL.g:972:1: ruleStringLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleStringLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleStringLiteralExpCS"


    // $ANTLR start "ruleStringLiteralExpCS"
    // InternalEssentialOCL.g:979:1: ruleStringLiteralExpCS : ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) ;
    public final void ruleStringLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:983:2: ( ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) )
            // InternalEssentialOCL.g:984:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            {
            // InternalEssentialOCL.g:984:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            // InternalEssentialOCL.g:985:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            {
            // InternalEssentialOCL.g:985:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) )
            // InternalEssentialOCL.g:986:1: ( rule__StringLiteralExpCS__SegmentsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }
            // InternalEssentialOCL.g:987:1: ( rule__StringLiteralExpCS__SegmentsAssignment )
            // InternalEssentialOCL.g:987:2: rule__StringLiteralExpCS__SegmentsAssignment
            {
            pushFollow(FollowSets000.FOLLOW_3);
            rule__StringLiteralExpCS__SegmentsAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }

            }

            // InternalEssentialOCL.g:990:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            // InternalEssentialOCL.g:991:1: ( rule__StringLiteralExpCS__SegmentsAssignment )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }
            // InternalEssentialOCL.g:992:1: ( rule__StringLiteralExpCS__SegmentsAssignment )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

                if ( (LA1_0==RULE_SINGLE_QUOTED_STRING) ) {
                    alt1=1;
                }


                switch (alt1) {
            	case 1 :
            	    // InternalEssentialOCL.g:992:2: rule__StringLiteralExpCS__SegmentsAssignment
            	    {
            	    pushFollow(FollowSets000.FOLLOW_3);
            	    rule__StringLiteralExpCS__SegmentsAssignment();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleStringLiteralExpCS"


    // $ANTLR start "entryRuleBooleanLiteralExpCS"
    // InternalEssentialOCL.g:1005:1: entryRuleBooleanLiteralExpCS : ruleBooleanLiteralExpCS EOF ;
    public final void entryRuleBooleanLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1006:1: ( ruleBooleanLiteralExpCS EOF )
            // InternalEssentialOCL.g:1007:1: ruleBooleanLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleBooleanLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleBooleanLiteralExpCS"


    // $ANTLR start "ruleBooleanLiteralExpCS"
    // InternalEssentialOCL.g:1014:1: ruleBooleanLiteralExpCS : ( ( rule__BooleanLiteralExpCS__Alternatives ) ) ;
    public final void ruleBooleanLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1018:2: ( ( ( rule__BooleanLiteralExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1019:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1019:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            // InternalEssentialOCL.g:1020:1: ( rule__BooleanLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1021:1: ( rule__BooleanLiteralExpCS__Alternatives )
            // InternalEssentialOCL.g:1021:2: rule__BooleanLiteralExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__BooleanLiteralExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleBooleanLiteralExpCS"


    // $ANTLR start "entryRuleUnlimitedNaturalLiteralExpCS"
    // InternalEssentialOCL.g:1033:1: entryRuleUnlimitedNaturalLiteralExpCS : ruleUnlimitedNaturalLiteralExpCS EOF ;
    public final void entryRuleUnlimitedNaturalLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1034:1: ( ruleUnlimitedNaturalLiteralExpCS EOF )
            // InternalEssentialOCL.g:1035:1: ruleUnlimitedNaturalLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUnlimitedNaturalLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUnlimitedNaturalLiteralExpCS"


    // $ANTLR start "ruleUnlimitedNaturalLiteralExpCS"
    // InternalEssentialOCL.g:1042:1: ruleUnlimitedNaturalLiteralExpCS : ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) ;
    public final void ruleUnlimitedNaturalLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1046:2: ( ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1047:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1047:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1048:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1049:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:1049:2: rule__UnlimitedNaturalLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUnlimitedNaturalLiteralExpCS"


    // $ANTLR start "entryRuleInvalidLiteralExpCS"
    // InternalEssentialOCL.g:1061:1: entryRuleInvalidLiteralExpCS : ruleInvalidLiteralExpCS EOF ;
    public final void entryRuleInvalidLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1062:1: ( ruleInvalidLiteralExpCS EOF )
            // InternalEssentialOCL.g:1063:1: ruleInvalidLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleInvalidLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleInvalidLiteralExpCS"


    // $ANTLR start "ruleInvalidLiteralExpCS"
    // InternalEssentialOCL.g:1070:1: ruleInvalidLiteralExpCS : ( ( rule__InvalidLiteralExpCS__Group__0 ) ) ;
    public final void ruleInvalidLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1074:2: ( ( ( rule__InvalidLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1075:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1075:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1076:1: ( rule__InvalidLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1077:1: ( rule__InvalidLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:1077:2: rule__InvalidLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleInvalidLiteralExpCS"


    // $ANTLR start "entryRuleNullLiteralExpCS"
    // InternalEssentialOCL.g:1089:1: entryRuleNullLiteralExpCS : ruleNullLiteralExpCS EOF ;
    public final void entryRuleNullLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1090:1: ( ruleNullLiteralExpCS EOF )
            // InternalEssentialOCL.g:1091:1: ruleNullLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNullLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNullLiteralExpCS"


    // $ANTLR start "ruleNullLiteralExpCS"
    // InternalEssentialOCL.g:1098:1: ruleNullLiteralExpCS : ( ( rule__NullLiteralExpCS__Group__0 ) ) ;
    public final void ruleNullLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1102:2: ( ( ( rule__NullLiteralExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1103:1: ( ( rule__NullLiteralExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1103:1: ( ( rule__NullLiteralExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1104:1: ( rule__NullLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1105:1: ( rule__NullLiteralExpCS__Group__0 )
            // InternalEssentialOCL.g:1105:2: rule__NullLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNullLiteralExpCS"


    // $ANTLR start "entryRuleTypeLiteralCS"
    // InternalEssentialOCL.g:1117:1: entryRuleTypeLiteralCS : ruleTypeLiteralCS EOF ;
    public final void entryRuleTypeLiteralCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1118:1: ( ruleTypeLiteralCS EOF )
            // InternalEssentialOCL.g:1119:1: ruleTypeLiteralCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeLiteralCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeLiteralCS"


    // $ANTLR start "ruleTypeLiteralCS"
    // InternalEssentialOCL.g:1126:1: ruleTypeLiteralCS : ( ( rule__TypeLiteralCS__Alternatives ) ) ;
    public final void ruleTypeLiteralCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1130:2: ( ( ( rule__TypeLiteralCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1131:1: ( ( rule__TypeLiteralCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1131:1: ( ( rule__TypeLiteralCS__Alternatives ) )
            // InternalEssentialOCL.g:1132:1: ( rule__TypeLiteralCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1133:1: ( rule__TypeLiteralCS__Alternatives )
            // InternalEssentialOCL.g:1133:2: rule__TypeLiteralCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeLiteralCS"


    // $ANTLR start "entryRuleTypeLiteralWithMultiplicityCS"
    // InternalEssentialOCL.g:1145:1: entryRuleTypeLiteralWithMultiplicityCS : ruleTypeLiteralWithMultiplicityCS EOF ;
    public final void entryRuleTypeLiteralWithMultiplicityCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1146:1: ( ruleTypeLiteralWithMultiplicityCS EOF )
            // InternalEssentialOCL.g:1147:1: ruleTypeLiteralWithMultiplicityCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeLiteralWithMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeLiteralWithMultiplicityCS"


    // $ANTLR start "ruleTypeLiteralWithMultiplicityCS"
    // InternalEssentialOCL.g:1154:1: ruleTypeLiteralWithMultiplicityCS : ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) ;
    public final void ruleTypeLiteralWithMultiplicityCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1158:2: ( ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1159:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1159:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            // InternalEssentialOCL.g:1160:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1161:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            // InternalEssentialOCL.g:1161:2: rule__TypeLiteralWithMultiplicityCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeLiteralWithMultiplicityCS"


    // $ANTLR start "entryRuleTypeLiteralExpCS"
    // InternalEssentialOCL.g:1173:1: entryRuleTypeLiteralExpCS : ruleTypeLiteralExpCS EOF ;
    public final void entryRuleTypeLiteralExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1174:1: ( ruleTypeLiteralExpCS EOF )
            // InternalEssentialOCL.g:1175:1: ruleTypeLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeLiteralExpCS"


    // $ANTLR start "ruleTypeLiteralExpCS"
    // InternalEssentialOCL.g:1182:1: ruleTypeLiteralExpCS : ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) ;
    public final void ruleTypeLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1186:2: ( ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) )
            // InternalEssentialOCL.g:1187:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            {
            // InternalEssentialOCL.g:1187:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            // InternalEssentialOCL.g:1188:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment());
            }
            // InternalEssentialOCL.g:1189:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            // InternalEssentialOCL.g:1189:2: rule__TypeLiteralExpCS__OwnedTypeAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralExpCS__OwnedTypeAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeLiteralExpCS"


    // $ANTLR start "entryRuleTypeNameExpCS"
    // InternalEssentialOCL.g:1201:1: entryRuleTypeNameExpCS : ruleTypeNameExpCS EOF ;
    public final void entryRuleTypeNameExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1202:1: ( ruleTypeNameExpCS EOF )
            // InternalEssentialOCL.g:1203:1: ruleTypeNameExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeNameExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeNameExpCS"


    // $ANTLR start "ruleTypeNameExpCS"
    // InternalEssentialOCL.g:1210:1: ruleTypeNameExpCS : ( ( rule__TypeNameExpCS__Group__0 ) ) ;
    public final void ruleTypeNameExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1214:2: ( ( ( rule__TypeNameExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1215:1: ( ( rule__TypeNameExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1215:1: ( ( rule__TypeNameExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1216:1: ( rule__TypeNameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1217:1: ( rule__TypeNameExpCS__Group__0 )
            // InternalEssentialOCL.g:1217:2: rule__TypeNameExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeNameExpCS"


    // $ANTLR start "entryRuleTypeExpWithoutMultiplicityCS"
    // InternalEssentialOCL.g:1229:1: entryRuleTypeExpWithoutMultiplicityCS : ruleTypeExpWithoutMultiplicityCS EOF ;
    public final void entryRuleTypeExpWithoutMultiplicityCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1230:1: ( ruleTypeExpWithoutMultiplicityCS EOF )
            // InternalEssentialOCL.g:1231:1: ruleTypeExpWithoutMultiplicityCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpWithoutMultiplicityCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeExpWithoutMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpWithoutMultiplicityCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeExpWithoutMultiplicityCS"


    // $ANTLR start "ruleTypeExpWithoutMultiplicityCS"
    // InternalEssentialOCL.g:1238:1: ruleTypeExpWithoutMultiplicityCS : ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) ;
    public final void ruleTypeExpWithoutMultiplicityCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1242:2: ( ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1243:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1243:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) )
            // InternalEssentialOCL.g:1244:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1245:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives )
            // InternalEssentialOCL.g:1245:2: rule__TypeExpWithoutMultiplicityCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpWithoutMultiplicityCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeExpWithoutMultiplicityCS"


    // $ANTLR start "entryRuleTypeExpCS"
    // InternalEssentialOCL.g:1257:1: entryRuleTypeExpCS : ruleTypeExpCS EOF ;
    public final void entryRuleTypeExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1258:1: ( ruleTypeExpCS EOF )
            // InternalEssentialOCL.g:1259:1: ruleTypeExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeExpCS"


    // $ANTLR start "ruleTypeExpCS"
    // InternalEssentialOCL.g:1266:1: ruleTypeExpCS : ( ( rule__TypeExpCS__Group__0 ) ) ;
    public final void ruleTypeExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1270:2: ( ( ( rule__TypeExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1271:1: ( ( rule__TypeExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1271:1: ( ( rule__TypeExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1272:1: ( rule__TypeExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1273:1: ( rule__TypeExpCS__Group__0 )
            // InternalEssentialOCL.g:1273:2: rule__TypeExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeExpCS"


    // $ANTLR start "entryRuleExpCS"
    // InternalEssentialOCL.g:1285:1: entryRuleExpCS : ruleExpCS EOF ;
    public final void entryRuleExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1286:1: ( ruleExpCS EOF )
            // InternalEssentialOCL.g:1287:1: ruleExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleExpCS"


    // $ANTLR start "ruleExpCS"
    // InternalEssentialOCL.g:1294:1: ruleExpCS : ( ( rule__ExpCS__Alternatives ) ) ;
    public final void ruleExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1298:2: ( ( ( rule__ExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1299:1: ( ( rule__ExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1299:1: ( ( rule__ExpCS__Alternatives ) )
            // InternalEssentialOCL.g:1300:1: ( rule__ExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1301:1: ( rule__ExpCS__Alternatives )
            // InternalEssentialOCL.g:1301:2: rule__ExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleExpCS"


    // $ANTLR start "entryRulePrefixedLetExpCS"
    // InternalEssentialOCL.g:1313:1: entryRulePrefixedLetExpCS : rulePrefixedLetExpCS EOF ;
    public final void entryRulePrefixedLetExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1314:1: ( rulePrefixedLetExpCS EOF )
            // InternalEssentialOCL.g:1315:1: rulePrefixedLetExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrefixedLetExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrefixedLetExpCS"


    // $ANTLR start "rulePrefixedLetExpCS"
    // InternalEssentialOCL.g:1322:1: rulePrefixedLetExpCS : ( ( rule__PrefixedLetExpCS__Alternatives ) ) ;
    public final void rulePrefixedLetExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1326:2: ( ( ( rule__PrefixedLetExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1327:1: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1327:1: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            // InternalEssentialOCL.g:1328:1: ( rule__PrefixedLetExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1329:1: ( rule__PrefixedLetExpCS__Alternatives )
            // InternalEssentialOCL.g:1329:2: rule__PrefixedLetExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrefixedLetExpCS"


    // $ANTLR start "entryRulePrefixedPrimaryExpCS"
    // InternalEssentialOCL.g:1341:1: entryRulePrefixedPrimaryExpCS : rulePrefixedPrimaryExpCS EOF ;
    public final void entryRulePrefixedPrimaryExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1342:1: ( rulePrefixedPrimaryExpCS EOF )
            // InternalEssentialOCL.g:1343:1: rulePrefixedPrimaryExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrefixedPrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrefixedPrimaryExpCS"


    // $ANTLR start "rulePrefixedPrimaryExpCS"
    // InternalEssentialOCL.g:1350:1: rulePrefixedPrimaryExpCS : ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) ;
    public final void rulePrefixedPrimaryExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1354:2: ( ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1355:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1355:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            // InternalEssentialOCL.g:1356:1: ( rule__PrefixedPrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1357:1: ( rule__PrefixedPrimaryExpCS__Alternatives )
            // InternalEssentialOCL.g:1357:2: rule__PrefixedPrimaryExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrefixedPrimaryExpCS"


    // $ANTLR start "entryRulePrimaryExpCS"
    // InternalEssentialOCL.g:1369:1: entryRulePrimaryExpCS : rulePrimaryExpCS EOF ;
    public final void entryRulePrimaryExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1370:1: ( rulePrimaryExpCS EOF )
            // InternalEssentialOCL.g:1371:1: rulePrimaryExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePrimaryExpCS"


    // $ANTLR start "rulePrimaryExpCS"
    // InternalEssentialOCL.g:1378:1: rulePrimaryExpCS : ( ( rule__PrimaryExpCS__Alternatives ) ) ;
    public final void rulePrimaryExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1382:2: ( ( ( rule__PrimaryExpCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1383:1: ( ( rule__PrimaryExpCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1383:1: ( ( rule__PrimaryExpCS__Alternatives ) )
            // InternalEssentialOCL.g:1384:1: ( rule__PrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1385:1: ( rule__PrimaryExpCS__Alternatives )
            // InternalEssentialOCL.g:1385:2: rule__PrimaryExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimaryExpCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimaryExpCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePrimaryExpCS"


    // $ANTLR start "entryRuleNameExpCS"
    // InternalEssentialOCL.g:1397:1: entryRuleNameExpCS : ruleNameExpCS EOF ;
    public final void entryRuleNameExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1398:1: ( ruleNameExpCS EOF )
            // InternalEssentialOCL.g:1399:1: ruleNameExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNameExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNameExpCS"


    // $ANTLR start "ruleNameExpCS"
    // InternalEssentialOCL.g:1406:1: ruleNameExpCS : ( ( rule__NameExpCS__Group__0 ) ) ;
    public final void ruleNameExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1410:2: ( ( ( rule__NameExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1411:1: ( ( rule__NameExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1411:1: ( ( rule__NameExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1412:1: ( rule__NameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1413:1: ( rule__NameExpCS__Group__0 )
            // InternalEssentialOCL.g:1413:2: rule__NameExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNameExpCS"


    // $ANTLR start "entryRuleCurlyBracketedClauseCS"
    // InternalEssentialOCL.g:1425:1: entryRuleCurlyBracketedClauseCS : ruleCurlyBracketedClauseCS EOF ;
    public final void entryRuleCurlyBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1426:1: ( ruleCurlyBracketedClauseCS EOF )
            // InternalEssentialOCL.g:1427:1: ruleCurlyBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCurlyBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCurlyBracketedClauseCS"


    // $ANTLR start "ruleCurlyBracketedClauseCS"
    // InternalEssentialOCL.g:1434:1: ruleCurlyBracketedClauseCS : ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) ;
    public final void ruleCurlyBracketedClauseCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1438:2: ( ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1439:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1439:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            // InternalEssentialOCL.g:1440:1: ( rule__CurlyBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1441:1: ( rule__CurlyBracketedClauseCS__Group__0 )
            // InternalEssentialOCL.g:1441:2: rule__CurlyBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCurlyBracketedClauseCS"


    // $ANTLR start "entryRuleRoundBracketedClauseCS"
    // InternalEssentialOCL.g:1453:1: entryRuleRoundBracketedClauseCS : ruleRoundBracketedClauseCS EOF ;
    public final void entryRuleRoundBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1454:1: ( ruleRoundBracketedClauseCS EOF )
            // InternalEssentialOCL.g:1455:1: ruleRoundBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleRoundBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleRoundBracketedClauseCS"


    // $ANTLR start "ruleRoundBracketedClauseCS"
    // InternalEssentialOCL.g:1462:1: ruleRoundBracketedClauseCS : ( ( rule__RoundBracketedClauseCS__Group__0 ) ) ;
    public final void ruleRoundBracketedClauseCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1466:2: ( ( ( rule__RoundBracketedClauseCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1467:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1467:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            // InternalEssentialOCL.g:1468:1: ( rule__RoundBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1469:1: ( rule__RoundBracketedClauseCS__Group__0 )
            // InternalEssentialOCL.g:1469:2: rule__RoundBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleRoundBracketedClauseCS"


    // $ANTLR start "entryRuleSquareBracketedClauseCS"
    // InternalEssentialOCL.g:1481:1: entryRuleSquareBracketedClauseCS : ruleSquareBracketedClauseCS EOF ;
    public final void entryRuleSquareBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1482:1: ( ruleSquareBracketedClauseCS EOF )
            // InternalEssentialOCL.g:1483:1: ruleSquareBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleSquareBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSquareBracketedClauseCS"


    // $ANTLR start "ruleSquareBracketedClauseCS"
    // InternalEssentialOCL.g:1490:1: ruleSquareBracketedClauseCS : ( ( rule__SquareBracketedClauseCS__Group__0 ) ) ;
    public final void ruleSquareBracketedClauseCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1494:2: ( ( ( rule__SquareBracketedClauseCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1495:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1495:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            // InternalEssentialOCL.g:1496:1: ( rule__SquareBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1497:1: ( rule__SquareBracketedClauseCS__Group__0 )
            // InternalEssentialOCL.g:1497:2: rule__SquareBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSquareBracketedClauseCS"


    // $ANTLR start "entryRuleNavigatingArgCS"
    // InternalEssentialOCL.g:1509:1: entryRuleNavigatingArgCS : ruleNavigatingArgCS EOF ;
    public final void entryRuleNavigatingArgCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1510:1: ( ruleNavigatingArgCS EOF )
            // InternalEssentialOCL.g:1511:1: ruleNavigatingArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigatingArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigatingArgCS"


    // $ANTLR start "ruleNavigatingArgCS"
    // InternalEssentialOCL.g:1518:1: ruleNavigatingArgCS : ( ( rule__NavigatingArgCS__Alternatives ) ) ;
    public final void ruleNavigatingArgCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1522:2: ( ( ( rule__NavigatingArgCS__Alternatives ) ) )
            // InternalEssentialOCL.g:1523:1: ( ( rule__NavigatingArgCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:1523:1: ( ( rule__NavigatingArgCS__Alternatives ) )
            // InternalEssentialOCL.g:1524:1: ( rule__NavigatingArgCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:1525:1: ( rule__NavigatingArgCS__Alternatives )
            // InternalEssentialOCL.g:1525:2: rule__NavigatingArgCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigatingArgCS"


    // $ANTLR start "entryRuleNavigatingBarArgCS"
    // InternalEssentialOCL.g:1537:1: entryRuleNavigatingBarArgCS : ruleNavigatingBarArgCS EOF ;
    public final void entryRuleNavigatingBarArgCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1538:1: ( ruleNavigatingBarArgCS EOF )
            // InternalEssentialOCL.g:1539:1: ruleNavigatingBarArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigatingBarArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigatingBarArgCS"


    // $ANTLR start "ruleNavigatingBarArgCS"
    // InternalEssentialOCL.g:1546:1: ruleNavigatingBarArgCS : ( ( rule__NavigatingBarArgCS__Group__0 ) ) ;
    public final void ruleNavigatingBarArgCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1550:2: ( ( ( rule__NavigatingBarArgCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1551:1: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1551:1: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            // InternalEssentialOCL.g:1552:1: ( rule__NavigatingBarArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1553:1: ( rule__NavigatingBarArgCS__Group__0 )
            // InternalEssentialOCL.g:1553:2: rule__NavigatingBarArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigatingBarArgCS"


    // $ANTLR start "entryRuleNavigatingCommaArgCS"
    // InternalEssentialOCL.g:1565:1: entryRuleNavigatingCommaArgCS : ruleNavigatingCommaArgCS EOF ;
    public final void entryRuleNavigatingCommaArgCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1566:1: ( ruleNavigatingCommaArgCS EOF )
            // InternalEssentialOCL.g:1567:1: ruleNavigatingCommaArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigatingCommaArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigatingCommaArgCS"


    // $ANTLR start "ruleNavigatingCommaArgCS"
    // InternalEssentialOCL.g:1574:1: ruleNavigatingCommaArgCS : ( ( rule__NavigatingCommaArgCS__Group__0 ) ) ;
    public final void ruleNavigatingCommaArgCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1578:2: ( ( ( rule__NavigatingCommaArgCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1579:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1579:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            // InternalEssentialOCL.g:1580:1: ( rule__NavigatingCommaArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1581:1: ( rule__NavigatingCommaArgCS__Group__0 )
            // InternalEssentialOCL.g:1581:2: rule__NavigatingCommaArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigatingCommaArgCS"


    // $ANTLR start "entryRuleNavigatingSemiArgCS"
    // InternalEssentialOCL.g:1593:1: entryRuleNavigatingSemiArgCS : ruleNavigatingSemiArgCS EOF ;
    public final void entryRuleNavigatingSemiArgCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1594:1: ( ruleNavigatingSemiArgCS EOF )
            // InternalEssentialOCL.g:1595:1: ruleNavigatingSemiArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigatingSemiArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigatingSemiArgCS"


    // $ANTLR start "ruleNavigatingSemiArgCS"
    // InternalEssentialOCL.g:1602:1: ruleNavigatingSemiArgCS : ( ( rule__NavigatingSemiArgCS__Group__0 ) ) ;
    public final void ruleNavigatingSemiArgCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1606:2: ( ( ( rule__NavigatingSemiArgCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1607:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1607:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            // InternalEssentialOCL.g:1608:1: ( rule__NavigatingSemiArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1609:1: ( rule__NavigatingSemiArgCS__Group__0 )
            // InternalEssentialOCL.g:1609:2: rule__NavigatingSemiArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigatingSemiArgCS"


    // $ANTLR start "entryRuleNavigatingArgExpCS"
    // InternalEssentialOCL.g:1621:1: entryRuleNavigatingArgExpCS : ruleNavigatingArgExpCS EOF ;
    public final void entryRuleNavigatingArgExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1622:1: ( ruleNavigatingArgExpCS EOF )
            // InternalEssentialOCL.g:1623:1: ruleNavigatingArgExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNavigatingArgExpCS"


    // $ANTLR start "ruleNavigatingArgExpCS"
    // InternalEssentialOCL.g:1630:1: ruleNavigatingArgExpCS : ( ruleExpCS ) ;
    public final void ruleNavigatingArgExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1634:2: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:1635:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:1635:1: ( ruleExpCS )
            // InternalEssentialOCL.g:1636:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNavigatingArgExpCS"


    // $ANTLR start "entryRuleCoIteratorVariableCS"
    // InternalEssentialOCL.g:1649:1: entryRuleCoIteratorVariableCS : ruleCoIteratorVariableCS EOF ;
    public final void entryRuleCoIteratorVariableCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1650:1: ( ruleCoIteratorVariableCS EOF )
            // InternalEssentialOCL.g:1651:1: ruleCoIteratorVariableCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleCoIteratorVariableCS"


    // $ANTLR start "ruleCoIteratorVariableCS"
    // InternalEssentialOCL.g:1658:1: ruleCoIteratorVariableCS : ( ( rule__CoIteratorVariableCS__Group__0 ) ) ;
    public final void ruleCoIteratorVariableCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1662:2: ( ( ( rule__CoIteratorVariableCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1663:1: ( ( rule__CoIteratorVariableCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1663:1: ( ( rule__CoIteratorVariableCS__Group__0 ) )
            // InternalEssentialOCL.g:1664:1: ( rule__CoIteratorVariableCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1665:1: ( rule__CoIteratorVariableCS__Group__0 )
            // InternalEssentialOCL.g:1665:2: rule__CoIteratorVariableCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleCoIteratorVariableCS"


    // $ANTLR start "entryRuleIfExpCS"
    // InternalEssentialOCL.g:1677:1: entryRuleIfExpCS : ruleIfExpCS EOF ;
    public final void entryRuleIfExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1678:1: ( ruleIfExpCS EOF )
            // InternalEssentialOCL.g:1679:1: ruleIfExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleIfExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleIfExpCS"


    // $ANTLR start "ruleIfExpCS"
    // InternalEssentialOCL.g:1686:1: ruleIfExpCS : ( ( rule__IfExpCS__Group__0 ) ) ;
    public final void ruleIfExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1690:2: ( ( ( rule__IfExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1691:1: ( ( rule__IfExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1691:1: ( ( rule__IfExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1692:1: ( rule__IfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1693:1: ( rule__IfExpCS__Group__0 )
            // InternalEssentialOCL.g:1693:2: rule__IfExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleIfExpCS"


    // $ANTLR start "entryRuleElseIfThenExpCS"
    // InternalEssentialOCL.g:1705:1: entryRuleElseIfThenExpCS : ruleElseIfThenExpCS EOF ;
    public final void entryRuleElseIfThenExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1706:1: ( ruleElseIfThenExpCS EOF )
            // InternalEssentialOCL.g:1707:1: ruleElseIfThenExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleElseIfThenExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleElseIfThenExpCS"


    // $ANTLR start "ruleElseIfThenExpCS"
    // InternalEssentialOCL.g:1714:1: ruleElseIfThenExpCS : ( ( rule__ElseIfThenExpCS__Group__0 ) ) ;
    public final void ruleElseIfThenExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1718:2: ( ( ( rule__ElseIfThenExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1719:1: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1719:1: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1720:1: ( rule__ElseIfThenExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1721:1: ( rule__ElseIfThenExpCS__Group__0 )
            // InternalEssentialOCL.g:1721:2: rule__ElseIfThenExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleElseIfThenExpCS"


    // $ANTLR start "entryRuleLetExpCS"
    // InternalEssentialOCL.g:1733:1: entryRuleLetExpCS : ruleLetExpCS EOF ;
    public final void entryRuleLetExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1734:1: ( ruleLetExpCS EOF )
            // InternalEssentialOCL.g:1735:1: ruleLetExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleLetExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleLetExpCS"


    // $ANTLR start "ruleLetExpCS"
    // InternalEssentialOCL.g:1742:1: ruleLetExpCS : ( ( rule__LetExpCS__Group__0 ) ) ;
    public final void ruleLetExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1746:2: ( ( ( rule__LetExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1747:1: ( ( rule__LetExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1747:1: ( ( rule__LetExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1748:1: ( rule__LetExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1749:1: ( rule__LetExpCS__Group__0 )
            // InternalEssentialOCL.g:1749:2: rule__LetExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleLetExpCS"


    // $ANTLR start "entryRuleLetVariableCS"
    // InternalEssentialOCL.g:1761:1: entryRuleLetVariableCS : ruleLetVariableCS EOF ;
    public final void entryRuleLetVariableCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1762:1: ( ruleLetVariableCS EOF )
            // InternalEssentialOCL.g:1763:1: ruleLetVariableCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleLetVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleLetVariableCS"


    // $ANTLR start "ruleLetVariableCS"
    // InternalEssentialOCL.g:1770:1: ruleLetVariableCS : ( ( rule__LetVariableCS__Group__0 ) ) ;
    public final void ruleLetVariableCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1774:2: ( ( ( rule__LetVariableCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1775:1: ( ( rule__LetVariableCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1775:1: ( ( rule__LetVariableCS__Group__0 ) )
            // InternalEssentialOCL.g:1776:1: ( rule__LetVariableCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1777:1: ( rule__LetVariableCS__Group__0 )
            // InternalEssentialOCL.g:1777:2: rule__LetVariableCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleLetVariableCS"


    // $ANTLR start "entryRuleNestedExpCS"
    // InternalEssentialOCL.g:1789:1: entryRuleNestedExpCS : ruleNestedExpCS EOF ;
    public final void entryRuleNestedExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1790:1: ( ruleNestedExpCS EOF )
            // InternalEssentialOCL.g:1791:1: ruleNestedExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNestedExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNestedExpCS"


    // $ANTLR start "ruleNestedExpCS"
    // InternalEssentialOCL.g:1798:1: ruleNestedExpCS : ( ( rule__NestedExpCS__Group__0 ) ) ;
    public final void ruleNestedExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1802:2: ( ( ( rule__NestedExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1803:1: ( ( rule__NestedExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1803:1: ( ( rule__NestedExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1804:1: ( rule__NestedExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1805:1: ( rule__NestedExpCS__Group__0 )
            // InternalEssentialOCL.g:1805:2: rule__NestedExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNestedExpCS"


    // $ANTLR start "entryRuleSelfExpCS"
    // InternalEssentialOCL.g:1817:1: entryRuleSelfExpCS : ruleSelfExpCS EOF ;
    public final void entryRuleSelfExpCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1818:1: ( ruleSelfExpCS EOF )
            // InternalEssentialOCL.g:1819:1: ruleSelfExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleSelfExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleSelfExpCS"


    // $ANTLR start "ruleSelfExpCS"
    // InternalEssentialOCL.g:1826:1: ruleSelfExpCS : ( ( rule__SelfExpCS__Group__0 ) ) ;
    public final void ruleSelfExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1830:2: ( ( ( rule__SelfExpCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1831:1: ( ( rule__SelfExpCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1831:1: ( ( rule__SelfExpCS__Group__0 ) )
            // InternalEssentialOCL.g:1832:1: ( rule__SelfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1833:1: ( rule__SelfExpCS__Group__0 )
            // InternalEssentialOCL.g:1833:2: rule__SelfExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleSelfExpCS"


    // $ANTLR start "entryRuleMultiplicityBoundsCS"
    // InternalEssentialOCL.g:1845:1: entryRuleMultiplicityBoundsCS : ruleMultiplicityBoundsCS EOF ;
    public final void entryRuleMultiplicityBoundsCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1846:1: ( ruleMultiplicityBoundsCS EOF )
            // InternalEssentialOCL.g:1847:1: ruleMultiplicityBoundsCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMultiplicityBoundsCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMultiplicityBoundsCS"


    // $ANTLR start "ruleMultiplicityBoundsCS"
    // InternalEssentialOCL.g:1854:1: ruleMultiplicityBoundsCS : ( ( rule__MultiplicityBoundsCS__Group__0 ) ) ;
    public final void ruleMultiplicityBoundsCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1858:2: ( ( ( rule__MultiplicityBoundsCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1859:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1859:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            // InternalEssentialOCL.g:1860:1: ( rule__MultiplicityBoundsCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1861:1: ( rule__MultiplicityBoundsCS__Group__0 )
            // InternalEssentialOCL.g:1861:2: rule__MultiplicityBoundsCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMultiplicityBoundsCS"


    // $ANTLR start "entryRuleMultiplicityCS"
    // InternalEssentialOCL.g:1873:1: entryRuleMultiplicityCS : ruleMultiplicityCS EOF ;
    public final void entryRuleMultiplicityCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1874:1: ( ruleMultiplicityCS EOF )
            // InternalEssentialOCL.g:1875:1: ruleMultiplicityCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMultiplicityCS"


    // $ANTLR start "ruleMultiplicityCS"
    // InternalEssentialOCL.g:1882:1: ruleMultiplicityCS : ( ( rule__MultiplicityCS__Group__0 ) ) ;
    public final void ruleMultiplicityCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1886:2: ( ( ( rule__MultiplicityCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1887:1: ( ( rule__MultiplicityCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1887:1: ( ( rule__MultiplicityCS__Group__0 ) )
            // InternalEssentialOCL.g:1888:1: ( rule__MultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1889:1: ( rule__MultiplicityCS__Group__0 )
            // InternalEssentialOCL.g:1889:2: rule__MultiplicityCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMultiplicityCS"


    // $ANTLR start "entryRuleMultiplicityStringCS"
    // InternalEssentialOCL.g:1901:1: entryRuleMultiplicityStringCS : ruleMultiplicityStringCS EOF ;
    public final void entryRuleMultiplicityStringCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1902:1: ( ruleMultiplicityStringCS EOF )
            // InternalEssentialOCL.g:1903:1: ruleMultiplicityStringCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleMultiplicityStringCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityStringCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleMultiplicityStringCS"


    // $ANTLR start "ruleMultiplicityStringCS"
    // InternalEssentialOCL.g:1910:1: ruleMultiplicityStringCS : ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) ;
    public final void ruleMultiplicityStringCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1914:2: ( ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) )
            // InternalEssentialOCL.g:1915:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            {
            // InternalEssentialOCL.g:1915:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            // InternalEssentialOCL.g:1916:1: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment());
            }
            // InternalEssentialOCL.g:1917:1: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            // InternalEssentialOCL.g:1917:2: rule__MultiplicityStringCS__StringBoundsAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityStringCS__StringBoundsAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleMultiplicityStringCS"


    // $ANTLR start "entryRulePathNameCS"
    // InternalEssentialOCL.g:1929:1: entryRulePathNameCS : rulePathNameCS EOF ;
    public final void entryRulePathNameCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1930:1: ( rulePathNameCS EOF )
            // InternalEssentialOCL.g:1931:1: rulePathNameCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRulePathNameCS"


    // $ANTLR start "rulePathNameCS"
    // InternalEssentialOCL.g:1938:1: rulePathNameCS : ( ( rule__PathNameCS__Group__0 ) ) ;
    public final void rulePathNameCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1942:2: ( ( ( rule__PathNameCS__Group__0 ) ) )
            // InternalEssentialOCL.g:1943:1: ( ( rule__PathNameCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:1943:1: ( ( rule__PathNameCS__Group__0 ) )
            // InternalEssentialOCL.g:1944:1: ( rule__PathNameCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:1945:1: ( rule__PathNameCS__Group__0 )
            // InternalEssentialOCL.g:1945:2: rule__PathNameCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rulePathNameCS"


    // $ANTLR start "entryRuleFirstPathElementCS"
    // InternalEssentialOCL.g:1959:1: entryRuleFirstPathElementCS : ruleFirstPathElementCS EOF ;
    public final void entryRuleFirstPathElementCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1960:1: ( ruleFirstPathElementCS EOF )
            // InternalEssentialOCL.g:1961:1: ruleFirstPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleFirstPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleFirstPathElementCS"


    // $ANTLR start "ruleFirstPathElementCS"
    // InternalEssentialOCL.g:1968:1: ruleFirstPathElementCS : ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) ;
    public final void ruleFirstPathElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:1972:2: ( ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) )
            // InternalEssentialOCL.g:1973:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            {
            // InternalEssentialOCL.g:1973:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            // InternalEssentialOCL.g:1974:1: ( rule__FirstPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment());
            }
            // InternalEssentialOCL.g:1975:1: ( rule__FirstPathElementCS__ReferredElementAssignment )
            // InternalEssentialOCL.g:1975:2: rule__FirstPathElementCS__ReferredElementAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__FirstPathElementCS__ReferredElementAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleFirstPathElementCS"


    // $ANTLR start "entryRuleNextPathElementCS"
    // InternalEssentialOCL.g:1987:1: entryRuleNextPathElementCS : ruleNextPathElementCS EOF ;
    public final void entryRuleNextPathElementCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:1988:1: ( ruleNextPathElementCS EOF )
            // InternalEssentialOCL.g:1989:1: ruleNextPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNextPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNextPathElementCS"


    // $ANTLR start "ruleNextPathElementCS"
    // InternalEssentialOCL.g:1996:1: ruleNextPathElementCS : ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) ;
    public final void ruleNextPathElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2000:2: ( ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) )
            // InternalEssentialOCL.g:2001:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            {
            // InternalEssentialOCL.g:2001:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            // InternalEssentialOCL.g:2002:1: ( rule__NextPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment());
            }
            // InternalEssentialOCL.g:2003:1: ( rule__NextPathElementCS__ReferredElementAssignment )
            // InternalEssentialOCL.g:2003:2: rule__NextPathElementCS__ReferredElementAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NextPathElementCS__ReferredElementAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNextPathElementCS"


    // $ANTLR start "entryRuleTemplateBindingCS"
    // InternalEssentialOCL.g:2015:1: entryRuleTemplateBindingCS : ruleTemplateBindingCS EOF ;
    public final void entryRuleTemplateBindingCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2016:1: ( ruleTemplateBindingCS EOF )
            // InternalEssentialOCL.g:2017:1: ruleTemplateBindingCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTemplateBindingCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTemplateBindingCS"


    // $ANTLR start "ruleTemplateBindingCS"
    // InternalEssentialOCL.g:2024:1: ruleTemplateBindingCS : ( ( rule__TemplateBindingCS__Group__0 ) ) ;
    public final void ruleTemplateBindingCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2028:2: ( ( ( rule__TemplateBindingCS__Group__0 ) ) )
            // InternalEssentialOCL.g:2029:1: ( ( rule__TemplateBindingCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:2029:1: ( ( rule__TemplateBindingCS__Group__0 ) )
            // InternalEssentialOCL.g:2030:1: ( rule__TemplateBindingCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:2031:1: ( rule__TemplateBindingCS__Group__0 )
            // InternalEssentialOCL.g:2031:2: rule__TemplateBindingCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTemplateBindingCS"


    // $ANTLR start "entryRuleTemplateParameterSubstitutionCS"
    // InternalEssentialOCL.g:2043:1: entryRuleTemplateParameterSubstitutionCS : ruleTemplateParameterSubstitutionCS EOF ;
    public final void entryRuleTemplateParameterSubstitutionCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2044:1: ( ruleTemplateParameterSubstitutionCS EOF )
            // InternalEssentialOCL.g:2045:1: ruleTemplateParameterSubstitutionCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTemplateParameterSubstitutionCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateParameterSubstitutionCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTemplateParameterSubstitutionCS"


    // $ANTLR start "ruleTemplateParameterSubstitutionCS"
    // InternalEssentialOCL.g:2052:1: ruleTemplateParameterSubstitutionCS : ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) ;
    public final void ruleTemplateParameterSubstitutionCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2056:2: ( ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) )
            // InternalEssentialOCL.g:2057:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            {
            // InternalEssentialOCL.g:2057:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            // InternalEssentialOCL.g:2058:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment());
            }
            // InternalEssentialOCL.g:2059:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            // InternalEssentialOCL.g:2059:2: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTemplateParameterSubstitutionCS"


    // $ANTLR start "entryRuleTypeParameterCS"
    // InternalEssentialOCL.g:2073:1: entryRuleTypeParameterCS : ruleTypeParameterCS EOF ;
    public final void entryRuleTypeParameterCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2074:1: ( ruleTypeParameterCS EOF )
            // InternalEssentialOCL.g:2075:1: ruleTypeParameterCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeParameterCS"


    // $ANTLR start "ruleTypeParameterCS"
    // InternalEssentialOCL.g:2082:1: ruleTypeParameterCS : ( ( rule__TypeParameterCS__Group__0 ) ) ;
    public final void ruleTypeParameterCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2086:2: ( ( ( rule__TypeParameterCS__Group__0 ) ) )
            // InternalEssentialOCL.g:2087:1: ( ( rule__TypeParameterCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:2087:1: ( ( rule__TypeParameterCS__Group__0 ) )
            // InternalEssentialOCL.g:2088:1: ( rule__TypeParameterCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:2089:1: ( rule__TypeParameterCS__Group__0 )
            // InternalEssentialOCL.g:2089:2: rule__TypeParameterCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeParameterCS"


    // $ANTLR start "entryRuleTypeRefCS"
    // InternalEssentialOCL.g:2101:1: entryRuleTypeRefCS : ruleTypeRefCS EOF ;
    public final void entryRuleTypeRefCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2102:1: ( ruleTypeRefCS EOF )
            // InternalEssentialOCL.g:2103:1: ruleTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeRefCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeRefCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypeRefCS"


    // $ANTLR start "ruleTypeRefCS"
    // InternalEssentialOCL.g:2110:1: ruleTypeRefCS : ( ( rule__TypeRefCS__Alternatives ) ) ;
    public final void ruleTypeRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2114:2: ( ( ( rule__TypeRefCS__Alternatives ) ) )
            // InternalEssentialOCL.g:2115:1: ( ( rule__TypeRefCS__Alternatives ) )
            {
            // InternalEssentialOCL.g:2115:1: ( ( rule__TypeRefCS__Alternatives ) )
            // InternalEssentialOCL.g:2116:1: ( rule__TypeRefCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeRefCSAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:2117:1: ( rule__TypeRefCS__Alternatives )
            // InternalEssentialOCL.g:2117:2: rule__TypeRefCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeRefCS__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeRefCSAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypeRefCS"


    // $ANTLR start "entryRuleTypedRefCS"
    // InternalEssentialOCL.g:2129:1: entryRuleTypedRefCS : ruleTypedRefCS EOF ;
    public final void entryRuleTypedRefCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2130:1: ( ruleTypedRefCS EOF )
            // InternalEssentialOCL.g:2131:1: ruleTypedRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedRefCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedRefCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypedRefCS"


    // $ANTLR start "ruleTypedRefCS"
    // InternalEssentialOCL.g:2138:1: ruleTypedRefCS : ( ruleTypedTypeRefCS ) ;
    public final void ruleTypedRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2142:2: ( ( ruleTypedTypeRefCS ) )
            // InternalEssentialOCL.g:2143:1: ( ruleTypedTypeRefCS )
            {
            // InternalEssentialOCL.g:2143:1: ( ruleTypedTypeRefCS )
            // InternalEssentialOCL.g:2144:1: ruleTypedTypeRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypedRefCS"


    // $ANTLR start "entryRuleTypedTypeRefCS"
    // InternalEssentialOCL.g:2157:1: entryRuleTypedTypeRefCS : ruleTypedTypeRefCS EOF ;
    public final void entryRuleTypedTypeRefCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2158:1: ( ruleTypedTypeRefCS EOF )
            // InternalEssentialOCL.g:2159:1: ruleTypedTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypedTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleTypedTypeRefCS"


    // $ANTLR start "ruleTypedTypeRefCS"
    // InternalEssentialOCL.g:2166:1: ruleTypedTypeRefCS : ( ( rule__TypedTypeRefCS__Group__0 ) ) ;
    public final void ruleTypedTypeRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2170:2: ( ( ( rule__TypedTypeRefCS__Group__0 ) ) )
            // InternalEssentialOCL.g:2171:1: ( ( rule__TypedTypeRefCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:2171:1: ( ( rule__TypedTypeRefCS__Group__0 ) )
            // InternalEssentialOCL.g:2172:1: ( rule__TypedTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:2173:1: ( rule__TypedTypeRefCS__Group__0 )
            // InternalEssentialOCL.g:2173:2: rule__TypedTypeRefCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleTypedTypeRefCS"


    // $ANTLR start "entryRuleWildcardTypeRefCS"
    // InternalEssentialOCL.g:2185:1: entryRuleWildcardTypeRefCS : ruleWildcardTypeRefCS EOF ;
    public final void entryRuleWildcardTypeRefCS() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2186:1: ( ruleWildcardTypeRefCS EOF )
            // InternalEssentialOCL.g:2187:1: ruleWildcardTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleWildcardTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleWildcardTypeRefCS"


    // $ANTLR start "ruleWildcardTypeRefCS"
    // InternalEssentialOCL.g:2194:1: ruleWildcardTypeRefCS : ( ( rule__WildcardTypeRefCS__Group__0 ) ) ;
    public final void ruleWildcardTypeRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2198:2: ( ( ( rule__WildcardTypeRefCS__Group__0 ) ) )
            // InternalEssentialOCL.g:2199:1: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            {
            // InternalEssentialOCL.g:2199:1: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            // InternalEssentialOCL.g:2200:1: ( rule__WildcardTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup());
            }
            // InternalEssentialOCL.g:2201:1: ( rule__WildcardTypeRefCS__Group__0 )
            // InternalEssentialOCL.g:2201:2: rule__WildcardTypeRefCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getGroup());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleWildcardTypeRefCS"


    // $ANTLR start "entryRuleID"
    // InternalEssentialOCL.g:2213:1: entryRuleID : ruleID EOF ;
    public final void entryRuleID() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2214:1: ( ruleID EOF )
            // InternalEssentialOCL.g:2215:1: ruleID EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIDRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleID();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIDRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleID"


    // $ANTLR start "ruleID"
    // InternalEssentialOCL.g:2222:1: ruleID : ( ( rule__ID__Alternatives ) ) ;
    public final void ruleID() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2226:2: ( ( ( rule__ID__Alternatives ) ) )
            // InternalEssentialOCL.g:2227:1: ( ( rule__ID__Alternatives ) )
            {
            // InternalEssentialOCL.g:2227:1: ( ( rule__ID__Alternatives ) )
            // InternalEssentialOCL.g:2228:1: ( rule__ID__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIDAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:2229:1: ( rule__ID__Alternatives )
            // InternalEssentialOCL.g:2229:2: rule__ID__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ID__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIDAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleID"


    // $ANTLR start "entryRuleIdentifier"
    // InternalEssentialOCL.g:2241:1: entryRuleIdentifier : ruleIdentifier EOF ;
    public final void entryRuleIdentifier() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2242:1: ( ruleIdentifier EOF )
            // InternalEssentialOCL.g:2243:1: ruleIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdentifierRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIdentifierRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleIdentifier"


    // $ANTLR start "ruleIdentifier"
    // InternalEssentialOCL.g:2250:1: ruleIdentifier : ( ruleID ) ;
    public final void ruleIdentifier() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2254:2: ( ( ruleID ) )
            // InternalEssentialOCL.g:2255:1: ( ruleID )
            {
            // InternalEssentialOCL.g:2255:1: ( ruleID )
            // InternalEssentialOCL.g:2256:1: ruleID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdentifierAccess().getIDParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleID();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIdentifierAccess().getIDParserRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleIdentifier"


    // $ANTLR start "entryRuleLOWER"
    // InternalEssentialOCL.g:2269:1: entryRuleLOWER : ruleLOWER EOF ;
    public final void entryRuleLOWER() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2270:1: ( ruleLOWER EOF )
            // InternalEssentialOCL.g:2271:1: ruleLOWER EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLOWERRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleLOWER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLOWERRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleLOWER"


    // $ANTLR start "ruleLOWER"
    // InternalEssentialOCL.g:2278:1: ruleLOWER : ( RULE_INT ) ;
    public final void ruleLOWER() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2282:2: ( ( RULE_INT ) )
            // InternalEssentialOCL.g:2283:1: ( RULE_INT )
            {
            // InternalEssentialOCL.g:2283:1: ( RULE_INT )
            // InternalEssentialOCL.g:2284:1: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLOWERAccess().getINTTerminalRuleCall());
            }
            match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLOWERAccess().getINTTerminalRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleLOWER"


    // $ANTLR start "entryRuleNUMBER_LITERAL"
    // InternalEssentialOCL.g:2297:1: entryRuleNUMBER_LITERAL : ruleNUMBER_LITERAL EOF ;
    public final void entryRuleNUMBER_LITERAL() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2298:1: ( ruleNUMBER_LITERAL EOF )
            // InternalEssentialOCL.g:2299:1: ruleNUMBER_LITERAL EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNUMBER_LITERALRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNUMBER_LITERAL();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNUMBER_LITERALRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleNUMBER_LITERAL"


    // $ANTLR start "ruleNUMBER_LITERAL"
    // InternalEssentialOCL.g:2306:1: ruleNUMBER_LITERAL : ( RULE_INT ) ;
    public final void ruleNUMBER_LITERAL() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2310:2: ( ( RULE_INT ) )
            // InternalEssentialOCL.g:2311:1: ( RULE_INT )
            {
            // InternalEssentialOCL.g:2311:1: ( RULE_INT )
            // InternalEssentialOCL.g:2312:1: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall());
            }
            match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleNUMBER_LITERAL"


    // $ANTLR start "entryRuleStringLiteral"
    // InternalEssentialOCL.g:2325:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
    public final void entryRuleStringLiteral() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2326:1: ( ruleStringLiteral EOF )
            // InternalEssentialOCL.g:2327:1: ruleStringLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleStringLiteral();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleStringLiteral"


    // $ANTLR start "ruleStringLiteral"
    // InternalEssentialOCL.g:2334:1: ruleStringLiteral : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void ruleStringLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2338:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalEssentialOCL.g:2339:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalEssentialOCL.g:2339:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalEssentialOCL.g:2340:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleStringLiteral"


    // $ANTLR start "entryRuleUPPER"
    // InternalEssentialOCL.g:2353:1: entryRuleUPPER : ruleUPPER EOF ;
    public final void entryRuleUPPER() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2354:1: ( ruleUPPER EOF )
            // InternalEssentialOCL.g:2355:1: ruleUPPER EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUPPERRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUPPER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUPPERRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleUPPER"


    // $ANTLR start "ruleUPPER"
    // InternalEssentialOCL.g:2362:1: ruleUPPER : ( ( rule__UPPER__Alternatives ) ) ;
    public final void ruleUPPER() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2366:2: ( ( ( rule__UPPER__Alternatives ) ) )
            // InternalEssentialOCL.g:2367:1: ( ( rule__UPPER__Alternatives ) )
            {
            // InternalEssentialOCL.g:2367:1: ( ( rule__UPPER__Alternatives ) )
            // InternalEssentialOCL.g:2368:1: ( rule__UPPER__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUPPERAccess().getAlternatives());
            }
            // InternalEssentialOCL.g:2369:1: ( rule__UPPER__Alternatives )
            // InternalEssentialOCL.g:2369:2: rule__UPPER__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UPPER__Alternatives();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUPPERAccess().getAlternatives());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleUPPER"


    // $ANTLR start "entryRuleURI"
    // InternalEssentialOCL.g:2381:1: entryRuleURI : ruleURI EOF ;
    public final void entryRuleURI() throws RecognitionException {
        try {
            // InternalEssentialOCL.g:2382:1: ( ruleURI EOF )
            // InternalEssentialOCL.g:2383:1: ruleURI EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleURI();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIRule());
            }
            match(input,EOF,FollowSets000.FOLLOW_2); if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
    // $ANTLR end "entryRuleURI"


    // $ANTLR start "ruleURI"
    // InternalEssentialOCL.g:2390:1: ruleURI : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void ruleURI() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2394:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalEssentialOCL.g:2395:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalEssentialOCL.g:2395:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalEssentialOCL.g:2396:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "ruleURI"


    // $ANTLR start "rule__EssentialOCLUnaryOperatorName__Alternatives"
    // InternalEssentialOCL.g:2410:1: rule__EssentialOCLUnaryOperatorName__Alternatives : ( ( '-' ) | ( 'not' ) | ( 'not2' ) );
    public final void rule__EssentialOCLUnaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2414:1: ( ( '-' ) | ( 'not' ) | ( 'not2' ) )
            int alt2=3;
            switch ( input.LA(1) ) {
            case 16:
                {
                alt2=1;
                }
                break;
            case 17:
                {
                alt2=2;
                }
                break;
            case 18:
                {
                alt2=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }

            switch (alt2) {
                case 1 :
                    // InternalEssentialOCL.g:2415:1: ( '-' )
                    {
                    // InternalEssentialOCL.g:2415:1: ( '-' )
                    // InternalEssentialOCL.g:2416:1: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0());
                    }
                    match(input,16,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2423:6: ( 'not' )
                    {
                    // InternalEssentialOCL.g:2423:6: ( 'not' )
                    // InternalEssentialOCL.g:2424:1: 'not'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2431:6: ( 'not2' )
                    {
                    // InternalEssentialOCL.g:2431:6: ( 'not2' )
                    // InternalEssentialOCL.g:2432:1: 'not2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2());
                    }
                    match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLUnaryOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLInfixOperatorName__Alternatives"
    // InternalEssentialOCL.g:2444:1: rule__EssentialOCLInfixOperatorName__Alternatives : ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) );
    public final void rule__EssentialOCLInfixOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2448:1: ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) )
            int alt3=18;
            switch ( input.LA(1) ) {
            case 19:
                {
                alt3=1;
                }
                break;
            case 20:
                {
                alt3=2;
                }
                break;
            case 21:
                {
                alt3=3;
                }
                break;
            case 16:
                {
                alt3=4;
                }
                break;
            case 22:
                {
                alt3=5;
                }
                break;
            case 23:
                {
                alt3=6;
                }
                break;
            case 24:
                {
                alt3=7;
                }
                break;
            case 25:
                {
                alt3=8;
                }
                break;
            case 26:
                {
                alt3=9;
                }
                break;
            case 27:
                {
                alt3=10;
                }
                break;
            case 28:
                {
                alt3=11;
                }
                break;
            case 29:
                {
                alt3=12;
                }
                break;
            case 30:
                {
                alt3=13;
                }
                break;
            case 31:
                {
                alt3=14;
                }
                break;
            case 32:
                {
                alt3=15;
                }
                break;
            case 33:
                {
                alt3=16;
                }
                break;
            case 34:
                {
                alt3=17;
                }
                break;
            case 35:
                {
                alt3=18;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // InternalEssentialOCL.g:2449:1: ( '*' )
                    {
                    // InternalEssentialOCL.g:2449:1: ( '*' )
                    // InternalEssentialOCL.g:2450:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0());
                    }
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2457:6: ( '/' )
                    {
                    // InternalEssentialOCL.g:2457:6: ( '/' )
                    // InternalEssentialOCL.g:2458:1: '/'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1());
                    }
                    match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2465:6: ( '+' )
                    {
                    // InternalEssentialOCL.g:2465:6: ( '+' )
                    // InternalEssentialOCL.g:2466:1: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2());
                    }
                    match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2473:6: ( '-' )
                    {
                    // InternalEssentialOCL.g:2473:6: ( '-' )
                    // InternalEssentialOCL.g:2474:1: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3());
                    }
                    match(input,16,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:2481:6: ( '>' )
                    {
                    // InternalEssentialOCL.g:2481:6: ( '>' )
                    // InternalEssentialOCL.g:2482:1: '>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4());
                    }
                    match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEssentialOCL.g:2489:6: ( '<' )
                    {
                    // InternalEssentialOCL.g:2489:6: ( '<' )
                    // InternalEssentialOCL.g:2490:1: '<'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5());
                    }
                    match(input,23,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalEssentialOCL.g:2497:6: ( '>=' )
                    {
                    // InternalEssentialOCL.g:2497:6: ( '>=' )
                    // InternalEssentialOCL.g:2498:1: '>='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6());
                    }
                    match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalEssentialOCL.g:2505:6: ( '<=' )
                    {
                    // InternalEssentialOCL.g:2505:6: ( '<=' )
                    // InternalEssentialOCL.g:2506:1: '<='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7());
                    }
                    match(input,25,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalEssentialOCL.g:2513:6: ( '=' )
                    {
                    // InternalEssentialOCL.g:2513:6: ( '=' )
                    // InternalEssentialOCL.g:2514:1: '='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8());
                    }
                    match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalEssentialOCL.g:2521:6: ( '<>' )
                    {
                    // InternalEssentialOCL.g:2521:6: ( '<>' )
                    // InternalEssentialOCL.g:2522:1: '<>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9());
                    }
                    match(input,27,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9());
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalEssentialOCL.g:2529:6: ( 'and' )
                    {
                    // InternalEssentialOCL.g:2529:6: ( 'and' )
                    // InternalEssentialOCL.g:2530:1: 'and'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10());
                    }
                    match(input,28,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10());
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalEssentialOCL.g:2537:6: ( 'and2' )
                    {
                    // InternalEssentialOCL.g:2537:6: ( 'and2' )
                    // InternalEssentialOCL.g:2538:1: 'and2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11());
                    }
                    match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11());
                    }

                    }


                    }
                    break;
                case 13 :
                    // InternalEssentialOCL.g:2545:6: ( 'implies' )
                    {
                    // InternalEssentialOCL.g:2545:6: ( 'implies' )
                    // InternalEssentialOCL.g:2546:1: 'implies'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12());
                    }
                    match(input,30,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12());
                    }

                    }


                    }
                    break;
                case 14 :
                    // InternalEssentialOCL.g:2553:6: ( 'implies2' )
                    {
                    // InternalEssentialOCL.g:2553:6: ( 'implies2' )
                    // InternalEssentialOCL.g:2554:1: 'implies2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13());
                    }
                    match(input,31,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13());
                    }

                    }


                    }
                    break;
                case 15 :
                    // InternalEssentialOCL.g:2561:6: ( 'or' )
                    {
                    // InternalEssentialOCL.g:2561:6: ( 'or' )
                    // InternalEssentialOCL.g:2562:1: 'or'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14());
                    }
                    match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14());
                    }

                    }


                    }
                    break;
                case 16 :
                    // InternalEssentialOCL.g:2569:6: ( 'or2' )
                    {
                    // InternalEssentialOCL.g:2569:6: ( 'or2' )
                    // InternalEssentialOCL.g:2570:1: 'or2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15());
                    }
                    match(input,33,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15());
                    }

                    }


                    }
                    break;
                case 17 :
                    // InternalEssentialOCL.g:2577:6: ( 'xor' )
                    {
                    // InternalEssentialOCL.g:2577:6: ( 'xor' )
                    // InternalEssentialOCL.g:2578:1: 'xor'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16());
                    }
                    match(input,34,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16());
                    }

                    }


                    }
                    break;
                case 18 :
                    // InternalEssentialOCL.g:2585:6: ( 'xor2' )
                    {
                    // InternalEssentialOCL.g:2585:6: ( 'xor2' )
                    // InternalEssentialOCL.g:2586:1: 'xor2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17());
                    }
                    match(input,35,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLInfixOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLNavigationOperatorName__Alternatives"
    // InternalEssentialOCL.g:2598:1: rule__EssentialOCLNavigationOperatorName__Alternatives : ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) );
    public final void rule__EssentialOCLNavigationOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2602:1: ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) )
            int alt4=4;
            switch ( input.LA(1) ) {
            case 36:
                {
                alt4=1;
                }
                break;
            case 37:
                {
                alt4=2;
                }
                break;
            case 38:
                {
                alt4=3;
                }
                break;
            case 39:
                {
                alt4=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }

            switch (alt4) {
                case 1 :
                    // InternalEssentialOCL.g:2603:1: ( '.' )
                    {
                    // InternalEssentialOCL.g:2603:1: ( '.' )
                    // InternalEssentialOCL.g:2604:1: '.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0());
                    }
                    match(input,36,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2611:6: ( '->' )
                    {
                    // InternalEssentialOCL.g:2611:6: ( '->' )
                    // InternalEssentialOCL.g:2612:1: '->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1());
                    }
                    match(input,37,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2619:6: ( '?.' )
                    {
                    // InternalEssentialOCL.g:2619:6: ( '?.' )
                    // InternalEssentialOCL.g:2620:1: '?.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2());
                    }
                    match(input,38,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2627:6: ( '?->' )
                    {
                    // InternalEssentialOCL.g:2627:6: ( '?->' )
                    // InternalEssentialOCL.g:2628:1: '?->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3());
                    }
                    match(input,39,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLNavigationOperatorName__Alternatives"


    // $ANTLR start "rule__BinaryOperatorName__Alternatives"
    // InternalEssentialOCL.g:2640:1: rule__BinaryOperatorName__Alternatives : ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) );
    public final void rule__BinaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2644:1: ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==16||(LA5_0>=19 && LA5_0<=35)) ) {
                alt5=1;
            }
            else if ( ((LA5_0>=36 && LA5_0<=39)) ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // InternalEssentialOCL.g:2645:1: ( ruleInfixOperatorName )
                    {
                    // InternalEssentialOCL.g:2645:1: ( ruleInfixOperatorName )
                    // InternalEssentialOCL.g:2646:1: ruleInfixOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleInfixOperatorName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2651:6: ( ruleNavigationOperatorName )
                    {
                    // InternalEssentialOCL.g:2651:6: ( ruleNavigationOperatorName )
                    // InternalEssentialOCL.g:2652:1: ruleNavigationOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigationOperatorName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BinaryOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLUnreservedName__Alternatives"
    // InternalEssentialOCL.g:2662:1: rule__EssentialOCLUnreservedName__Alternatives : ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) );
    public final void rule__EssentialOCLUnreservedName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2666:1: ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) )
            int alt6=5;
            switch ( input.LA(1) ) {
            case RULE_SIMPLE_ID:
            case RULE_ESCAPED_ID:
                {
                alt6=1;
                }
                break;
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
                {
                alt6=2;
                }
                break;
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
                {
                alt6=3;
                }
                break;
            case 40:
                {
                alt6=4;
                }
                break;
            case 41:
                {
                alt6=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }

            switch (alt6) {
                case 1 :
                    // InternalEssentialOCL.g:2667:1: ( ruleUnrestrictedName )
                    {
                    // InternalEssentialOCL.g:2667:1: ( ruleUnrestrictedName )
                    // InternalEssentialOCL.g:2668:1: ruleUnrestrictedName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2673:6: ( ruleCollectionTypeIdentifier )
                    {
                    // InternalEssentialOCL.g:2673:6: ( ruleCollectionTypeIdentifier )
                    // InternalEssentialOCL.g:2674:1: ruleCollectionTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionTypeIdentifier();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2679:6: ( rulePrimitiveTypeIdentifier )
                    {
                    // InternalEssentialOCL.g:2679:6: ( rulePrimitiveTypeIdentifier )
                    // InternalEssentialOCL.g:2680:1: rulePrimitiveTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveTypeIdentifier();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2685:6: ( 'Map' )
                    {
                    // InternalEssentialOCL.g:2685:6: ( 'Map' )
                    // InternalEssentialOCL.g:2686:1: 'Map'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3());
                    }
                    match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:2693:6: ( 'Tuple' )
                    {
                    // InternalEssentialOCL.g:2693:6: ( 'Tuple' )
                    // InternalEssentialOCL.g:2694:1: 'Tuple'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4());
                    }
                    match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLUnreservedName__Alternatives"


    // $ANTLR start "rule__URIFirstPathElementCS__Alternatives"
    // InternalEssentialOCL.g:2706:1: rule__URIFirstPathElementCS__Alternatives : ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) );
    public final void rule__URIFirstPathElementCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2710:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) )
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( ((LA7_0>=RULE_SIMPLE_ID && LA7_0<=RULE_ESCAPED_ID)) ) {
                alt7=1;
            }
            else if ( (LA7_0==RULE_SINGLE_QUOTED_STRING) ) {
                alt7=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // InternalEssentialOCL.g:2711:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    {
                    // InternalEssentialOCL.g:2711:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    // InternalEssentialOCL.g:2712:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0());
                    }
                    // InternalEssentialOCL.g:2713:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    // InternalEssentialOCL.g:2713:2: rule__URIFirstPathElementCS__ReferredElementAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__URIFirstPathElementCS__ReferredElementAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2717:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    {
                    // InternalEssentialOCL.g:2717:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    // InternalEssentialOCL.g:2718:1: ( rule__URIFirstPathElementCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1());
                    }
                    // InternalEssentialOCL.g:2719:1: ( rule__URIFirstPathElementCS__Group_1__0 )
                    // InternalEssentialOCL.g:2719:2: rule__URIFirstPathElementCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__URIFirstPathElementCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Alternatives"


    // $ANTLR start "rule__PrimitiveTypeIdentifier__Alternatives"
    // InternalEssentialOCL.g:2728:1: rule__PrimitiveTypeIdentifier__Alternatives : ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) );
    public final void rule__PrimitiveTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2732:1: ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) )
            int alt8=8;
            switch ( input.LA(1) ) {
            case 42:
                {
                alt8=1;
                }
                break;
            case 43:
                {
                alt8=2;
                }
                break;
            case 44:
                {
                alt8=3;
                }
                break;
            case 45:
                {
                alt8=4;
                }
                break;
            case 46:
                {
                alt8=5;
                }
                break;
            case 47:
                {
                alt8=6;
                }
                break;
            case 48:
                {
                alt8=7;
                }
                break;
            case 49:
                {
                alt8=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }

            switch (alt8) {
                case 1 :
                    // InternalEssentialOCL.g:2733:1: ( 'Boolean' )
                    {
                    // InternalEssentialOCL.g:2733:1: ( 'Boolean' )
                    // InternalEssentialOCL.g:2734:1: 'Boolean'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0());
                    }
                    match(input,42,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2741:6: ( 'Integer' )
                    {
                    // InternalEssentialOCL.g:2741:6: ( 'Integer' )
                    // InternalEssentialOCL.g:2742:1: 'Integer'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1());
                    }
                    match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2749:6: ( 'Real' )
                    {
                    // InternalEssentialOCL.g:2749:6: ( 'Real' )
                    // InternalEssentialOCL.g:2750:1: 'Real'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2());
                    }
                    match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2757:6: ( 'String' )
                    {
                    // InternalEssentialOCL.g:2757:6: ( 'String' )
                    // InternalEssentialOCL.g:2758:1: 'String'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3());
                    }
                    match(input,45,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:2765:6: ( 'UnlimitedNatural' )
                    {
                    // InternalEssentialOCL.g:2765:6: ( 'UnlimitedNatural' )
                    // InternalEssentialOCL.g:2766:1: 'UnlimitedNatural'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4());
                    }
                    match(input,46,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEssentialOCL.g:2773:6: ( 'OclAny' )
                    {
                    // InternalEssentialOCL.g:2773:6: ( 'OclAny' )
                    // InternalEssentialOCL.g:2774:1: 'OclAny'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5());
                    }
                    match(input,47,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalEssentialOCL.g:2781:6: ( 'OclInvalid' )
                    {
                    // InternalEssentialOCL.g:2781:6: ( 'OclInvalid' )
                    // InternalEssentialOCL.g:2782:1: 'OclInvalid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6());
                    }
                    match(input,48,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalEssentialOCL.g:2789:6: ( 'OclVoid' )
                    {
                    // InternalEssentialOCL.g:2789:6: ( 'OclVoid' )
                    // InternalEssentialOCL.g:2790:1: 'OclVoid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7());
                    }
                    match(input,49,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveTypeIdentifier__Alternatives"


    // $ANTLR start "rule__CollectionTypeIdentifier__Alternatives"
    // InternalEssentialOCL.g:2802:1: rule__CollectionTypeIdentifier__Alternatives : ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) );
    public final void rule__CollectionTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2806:1: ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) )
            int alt9=5;
            switch ( input.LA(1) ) {
            case 50:
                {
                alt9=1;
                }
                break;
            case 51:
                {
                alt9=2;
                }
                break;
            case 52:
                {
                alt9=3;
                }
                break;
            case 53:
                {
                alt9=4;
                }
                break;
            case 54:
                {
                alt9=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }

            switch (alt9) {
                case 1 :
                    // InternalEssentialOCL.g:2807:1: ( 'Set' )
                    {
                    // InternalEssentialOCL.g:2807:1: ( 'Set' )
                    // InternalEssentialOCL.g:2808:1: 'Set'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0());
                    }
                    match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2815:6: ( 'Bag' )
                    {
                    // InternalEssentialOCL.g:2815:6: ( 'Bag' )
                    // InternalEssentialOCL.g:2816:1: 'Bag'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1());
                    }
                    match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2823:6: ( 'Sequence' )
                    {
                    // InternalEssentialOCL.g:2823:6: ( 'Sequence' )
                    // InternalEssentialOCL.g:2824:1: 'Sequence'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2());
                    }
                    match(input,52,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2831:6: ( 'Collection' )
                    {
                    // InternalEssentialOCL.g:2831:6: ( 'Collection' )
                    // InternalEssentialOCL.g:2832:1: 'Collection'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3());
                    }
                    match(input,53,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:2839:6: ( 'OrderedSet' )
                    {
                    // InternalEssentialOCL.g:2839:6: ( 'OrderedSet' )
                    // InternalEssentialOCL.g:2840:1: 'OrderedSet'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4());
                    }
                    match(input,54,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeIdentifier__Alternatives"


    // $ANTLR start "rule__CollectionLiteralPartCS__Alternatives"
    // InternalEssentialOCL.g:2852:1: rule__CollectionLiteralPartCS__Alternatives : ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) );
    public final void rule__CollectionLiteralPartCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2856:1: ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) )
            int alt10=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 16:
            case 17:
            case 18:
            case 19:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 59:
            case 67:
            case 68:
            case 69:
            case 74:
            case 79:
            case 80:
            case 84:
            case 85:
                {
                alt10=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA10_2 = input.LA(2);

                if ( (LA10_2==62) ) {
                    alt10=2;
                }
                else if ( (LA10_2==EOF||LA10_2==16||(LA10_2>=19 && LA10_2<=39)||LA10_2==59||LA10_2==61||(LA10_2>=63 && LA10_2<=65)||LA10_2==71||LA10_2==81||LA10_2==86) ) {
                    alt10=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA10_3 = input.LA(2);

                if ( (LA10_3==EOF||LA10_3==16||(LA10_3>=19 && LA10_3<=39)||LA10_3==59||LA10_3==61||(LA10_3>=63 && LA10_3<=65)||LA10_3==71||LA10_3==81||LA10_3==86) ) {
                    alt10=1;
                }
                else if ( (LA10_3==62) ) {
                    alt10=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 3, input);

                    throw nvae;
                }
                }
                break;
            case 62:
                {
                alt10=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }

            switch (alt10) {
                case 1 :
                    // InternalEssentialOCL.g:2857:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:2857:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:2858:1: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:2859:1: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    // InternalEssentialOCL.g:2859:2: rule__CollectionLiteralPartCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2863:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    {
                    // InternalEssentialOCL.g:2863:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    // InternalEssentialOCL.g:2864:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1());
                    }
                    // InternalEssentialOCL.g:2865:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    // InternalEssentialOCL.g:2865:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Alternatives"


    // $ANTLR start "rule__ShadowPartCS__Alternatives"
    // InternalEssentialOCL.g:2874:1: rule__ShadowPartCS__Alternatives : ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) );
    public final void rule__ShadowPartCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2878:1: ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( ((LA11_0>=RULE_SIMPLE_ID && LA11_0<=RULE_ESCAPED_ID)) ) {
                alt11=1;
            }
            else if ( (LA11_0==RULE_SINGLE_QUOTED_STRING) ) {
                alt11=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // InternalEssentialOCL.g:2879:1: ( ( rule__ShadowPartCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:2879:1: ( ( rule__ShadowPartCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:2880:1: ( rule__ShadowPartCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:2881:1: ( rule__ShadowPartCS__Group_0__0 )
                    // InternalEssentialOCL.g:2881:2: rule__ShadowPartCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ShadowPartCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2885:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) )
                    {
                    // InternalEssentialOCL.g:2885:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) )
                    // InternalEssentialOCL.g:2886:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1());
                    }
                    // InternalEssentialOCL.g:2887:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 )
                    // InternalEssentialOCL.g:2887:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ShadowPartCS__OwnedInitExpressionAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Alternatives"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0"
    // InternalEssentialOCL.g:2896:1: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2900:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt12=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 16:
            case 17:
            case 18:
            case 19:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 59:
            case 67:
            case 68:
            case 69:
            case 74:
            case 79:
            case 80:
            case 84:
            case 85:
                {
                alt12=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA12_2 = input.LA(2);

                if ( (LA12_2==62) ) {
                    alt12=2;
                }
                else if ( (LA12_2==EOF||LA12_2==16||(LA12_2>=19 && LA12_2<=39)||LA12_2==59||LA12_2==61||(LA12_2>=63 && LA12_2<=64)||LA12_2==71||LA12_2==81||LA12_2==86) ) {
                    alt12=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA12_3 = input.LA(2);

                if ( (LA12_3==EOF||LA12_3==16||(LA12_3>=19 && LA12_3<=39)||LA12_3==59||LA12_3==61||(LA12_3>=63 && LA12_3<=64)||LA12_3==71||LA12_3==81||LA12_3==86) ) {
                    alt12=1;
                }
                else if ( (LA12_3==62) ) {
                    alt12=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 12, 3, input);

                    throw nvae;
                }
                }
                break;
            case 62:
                {
                alt12=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }

            switch (alt12) {
                case 1 :
                    // InternalEssentialOCL.g:2901:1: ( ruleExpCS )
                    {
                    // InternalEssentialOCL.g:2901:1: ( ruleExpCS )
                    // InternalEssentialOCL.g:2902:1: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2907:6: ( rulePatternExpCS )
                    {
                    // InternalEssentialOCL.g:2907:6: ( rulePatternExpCS )
                    // InternalEssentialOCL.g:2908:1: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePatternExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0"


    // $ANTLR start "rule__MapLiteralPartCS__Alternatives_1"
    // InternalEssentialOCL.g:2918:1: rule__MapLiteralPartCS__Alternatives_1 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__MapLiteralPartCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2922:1: ( ( 'with' ) | ( '<-' ) )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==55) ) {
                alt13=1;
            }
            else if ( (LA13_0==56) ) {
                alt13=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // InternalEssentialOCL.g:2923:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:2923:1: ( 'with' )
                    // InternalEssentialOCL.g:2924:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMapLiteralPartCSAccess().getWithKeyword_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2931:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:2931:6: ( '<-' )
                    // InternalEssentialOCL.g:2932:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Alternatives_1"


    // $ANTLR start "rule__PrimitiveLiteralExpCS__Alternatives"
    // InternalEssentialOCL.g:2944:1: rule__PrimitiveLiteralExpCS__Alternatives : ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) );
    public final void rule__PrimitiveLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2948:1: ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) )
            int alt14=6;
            switch ( input.LA(1) ) {
            case RULE_INT:
                {
                alt14=1;
                }
                break;
            case RULE_SINGLE_QUOTED_STRING:
                {
                alt14=2;
                }
                break;
            case 84:
            case 85:
                {
                alt14=3;
                }
                break;
            case 19:
                {
                alt14=4;
                }
                break;
            case 68:
                {
                alt14=5;
                }
                break;
            case 69:
                {
                alt14=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }

            switch (alt14) {
                case 1 :
                    // InternalEssentialOCL.g:2949:1: ( ruleNumberLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2949:1: ( ruleNumberLiteralExpCS )
                    // InternalEssentialOCL.g:2950:1: ruleNumberLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNumberLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:2955:6: ( ruleStringLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2955:6: ( ruleStringLiteralExpCS )
                    // InternalEssentialOCL.g:2956:1: ruleStringLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleStringLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:2961:6: ( ruleBooleanLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2961:6: ( ruleBooleanLiteralExpCS )
                    // InternalEssentialOCL.g:2962:1: ruleBooleanLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleBooleanLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:2967:6: ( ruleUnlimitedNaturalLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2967:6: ( ruleUnlimitedNaturalLiteralExpCS )
                    // InternalEssentialOCL.g:2968:1: ruleUnlimitedNaturalLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnlimitedNaturalLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:2973:6: ( ruleInvalidLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2973:6: ( ruleInvalidLiteralExpCS )
                    // InternalEssentialOCL.g:2974:1: ruleInvalidLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleInvalidLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEssentialOCL.g:2979:6: ( ruleNullLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:2979:6: ( ruleNullLiteralExpCS )
                    // InternalEssentialOCL.g:2980:1: ruleNullLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNullLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveLiteralExpCS__Alternatives"


    // $ANTLR start "rule__BooleanLiteralExpCS__Alternatives"
    // InternalEssentialOCL.g:2990:1: rule__BooleanLiteralExpCS__Alternatives : ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) );
    public final void rule__BooleanLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:2994:1: ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) )
            int alt15=2;
            int LA15_0 = input.LA(1);

            if ( (LA15_0==84) ) {
                alt15=1;
            }
            else if ( (LA15_0==85) ) {
                alt15=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }
            switch (alt15) {
                case 1 :
                    // InternalEssentialOCL.g:2995:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    {
                    // InternalEssentialOCL.g:2995:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    // InternalEssentialOCL.g:2996:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0());
                    }
                    // InternalEssentialOCL.g:2997:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    // InternalEssentialOCL.g:2997:2: rule__BooleanLiteralExpCS__SymbolAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__BooleanLiteralExpCS__SymbolAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3001:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    {
                    // InternalEssentialOCL.g:3001:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    // InternalEssentialOCL.g:3002:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1());
                    }
                    // InternalEssentialOCL.g:3003:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    // InternalEssentialOCL.g:3003:2: rule__BooleanLiteralExpCS__SymbolAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__BooleanLiteralExpCS__SymbolAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Alternatives"


    // $ANTLR start "rule__TypeLiteralCS__Alternatives"
    // InternalEssentialOCL.g:3012:1: rule__TypeLiteralCS__Alternatives : ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) );
    public final void rule__TypeLiteralCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3016:1: ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) )
            int alt16=4;
            switch ( input.LA(1) ) {
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
                {
                alt16=1;
                }
                break;
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
                {
                alt16=2;
                }
                break;
            case 40:
                {
                alt16=3;
                }
                break;
            case 41:
                {
                alt16=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }

            switch (alt16) {
                case 1 :
                    // InternalEssentialOCL.g:3017:1: ( rulePrimitiveTypeCS )
                    {
                    // InternalEssentialOCL.g:3017:1: ( rulePrimitiveTypeCS )
                    // InternalEssentialOCL.g:3018:1: rulePrimitiveTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3023:6: ( ruleCollectionTypeCS )
                    {
                    // InternalEssentialOCL.g:3023:6: ( ruleCollectionTypeCS )
                    // InternalEssentialOCL.g:3024:1: ruleCollectionTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3029:6: ( ruleMapTypeCS )
                    {
                    // InternalEssentialOCL.g:3029:6: ( ruleMapTypeCS )
                    // InternalEssentialOCL.g:3030:1: ruleMapTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMapTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:3035:6: ( ruleTupleTypeCS )
                    {
                    // InternalEssentialOCL.g:3035:6: ( ruleTupleTypeCS )
                    // InternalEssentialOCL.g:3036:1: ruleTupleTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTupleTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralCS__Alternatives"


    // $ANTLR start "rule__TypeExpWithoutMultiplicityCS__Alternatives"
    // InternalEssentialOCL.g:3046:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );
    public final void rule__TypeExpWithoutMultiplicityCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3050:1: ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) )
            int alt17=3;
            alt17 = dfa17.predict(input);
            switch (alt17) {
                case 1 :
                    // InternalEssentialOCL.g:3051:1: ( ruleTypeNameExpCS )
                    {
                    // InternalEssentialOCL.g:3051:1: ( ruleTypeNameExpCS )
                    // InternalEssentialOCL.g:3052:1: ruleTypeNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeNameExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS )
                    {
                    // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS )
                    // InternalEssentialOCL.g:3058:1: ruleTypeLiteralCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeLiteralCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3063:6: ( ruleCollectionPatternCS )
                    {
                    // InternalEssentialOCL.g:3063:6: ( ruleCollectionPatternCS )
                    // InternalEssentialOCL.g:3064:1: ruleCollectionPatternCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionPatternCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpWithoutMultiplicityCS__Alternatives"


    // $ANTLR start "rule__ExpCS__Alternatives"
    // InternalEssentialOCL.g:3074:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );
    public final void rule__ExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3078:1: ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) )
            int alt18=2;
            alt18 = dfa18.predict(input);
            switch (alt18) {
                case 1 :
                    // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:3080:1: ( rule__ExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:3081:1: ( rule__ExpCS__Group_0__0 )
                    // InternalEssentialOCL.g:3081:2: rule__ExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3085:6: ( rulePrefixedLetExpCS )
                    {
                    // InternalEssentialOCL.g:3085:6: ( rulePrefixedLetExpCS )
                    // InternalEssentialOCL.g:3086:1: rulePrefixedLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrefixedLetExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Alternatives"


    // $ANTLR start "rule__PrefixedLetExpCS__Alternatives"
    // InternalEssentialOCL.g:3096:1: rule__PrefixedLetExpCS__Alternatives : ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) );
    public final void rule__PrefixedLetExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3100:1: ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) )
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( ((LA19_0>=16 && LA19_0<=18)) ) {
                alt19=1;
            }
            else if ( (LA19_0==79) ) {
                alt19=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;
            }
            switch (alt19) {
                case 1 :
                    // InternalEssentialOCL.g:3101:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3101:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:3102:1: ( rule__PrefixedLetExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:3103:1: ( rule__PrefixedLetExpCS__Group_0__0 )
                    // InternalEssentialOCL.g:3103:2: rule__PrefixedLetExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PrefixedLetExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3107:6: ( ruleLetExpCS )
                    {
                    // InternalEssentialOCL.g:3107:6: ( ruleLetExpCS )
                    // InternalEssentialOCL.g:3108:1: ruleLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleLetExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Alternatives"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Alternatives"
    // InternalEssentialOCL.g:3118:1: rule__PrefixedPrimaryExpCS__Alternatives : ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) );
    public final void rule__PrefixedPrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3122:1: ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) )
            int alt20=2;
            int LA20_0 = input.LA(1);

            if ( ((LA20_0>=16 && LA20_0<=18)) ) {
                alt20=1;
            }
            else if ( ((LA20_0>=RULE_INT && LA20_0<=RULE_ESCAPED_ID)||LA20_0==19||(LA20_0>=40 && LA20_0<=54)||LA20_0==59||(LA20_0>=67 && LA20_0<=69)||LA20_0==74||LA20_0==80||(LA20_0>=84 && LA20_0<=85)) ) {
                alt20=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }
            switch (alt20) {
                case 1 :
                    // InternalEssentialOCL.g:3123:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3123:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:3124:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:3125:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    // InternalEssentialOCL.g:3125:2: rule__PrefixedPrimaryExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PrefixedPrimaryExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3129:6: ( rulePrimaryExpCS )
                    {
                    // InternalEssentialOCL.g:3129:6: ( rulePrimaryExpCS )
                    // InternalEssentialOCL.g:3130:1: rulePrimaryExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimaryExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Alternatives"


    // $ANTLR start "rule__PrimaryExpCS__Alternatives"
    // InternalEssentialOCL.g:3140:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) );
    public final void rule__PrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3144:1: ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) )
            int alt21=10;
            alt21 = dfa21.predict(input);
            switch (alt21) {
                case 1 :
                    // InternalEssentialOCL.g:3145:1: ( ruleNestedExpCS )
                    {
                    // InternalEssentialOCL.g:3145:1: ( ruleNestedExpCS )
                    // InternalEssentialOCL.g:3146:1: ruleNestedExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNestedExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3151:6: ( ruleIfExpCS )
                    {
                    // InternalEssentialOCL.g:3151:6: ( ruleIfExpCS )
                    // InternalEssentialOCL.g:3152:1: ruleIfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleIfExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3157:6: ( ruleSelfExpCS )
                    {
                    // InternalEssentialOCL.g:3157:6: ( ruleSelfExpCS )
                    // InternalEssentialOCL.g:3158:1: ruleSelfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleSelfExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEssentialOCL.g:3163:6: ( rulePrimitiveLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3163:6: ( rulePrimitiveLiteralExpCS )
                    // InternalEssentialOCL.g:3164:1: rulePrimitiveLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS )
                    // InternalEssentialOCL.g:3170:1: ruleTupleLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTupleLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS )
                    // InternalEssentialOCL.g:3176:1: ruleMapLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMapLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS )
                    // InternalEssentialOCL.g:3182:1: ruleCollectionLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalEssentialOCL.g:3187:6: ( ruleLambdaLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3187:6: ( ruleLambdaLiteralExpCS )
                    // InternalEssentialOCL.g:3188:1: ruleLambdaLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleLambdaLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS )
                    {
                    // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS )
                    // InternalEssentialOCL.g:3194:1: ruleTypeLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalEssentialOCL.g:3199:6: ( ruleNameExpCS )
                    {
                    // InternalEssentialOCL.g:3199:6: ( ruleNameExpCS )
                    // InternalEssentialOCL.g:3200:1: ruleNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNameExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpCS__Alternatives"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0"
    // InternalEssentialOCL.g:3210:1: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 : ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) );
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3214:1: ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) )
            int alt22=3;
            switch ( input.LA(1) ) {
            case 61:
                {
                alt22=1;
                }
                break;
            case 88:
                {
                alt22=2;
                }
                break;
            case 87:
                {
                alt22=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }

            switch (alt22) {
                case 1 :
                    // InternalEssentialOCL.g:3215:1: ( ruleNavigatingCommaArgCS )
                    {
                    // InternalEssentialOCL.g:3215:1: ( ruleNavigatingCommaArgCS )
                    // InternalEssentialOCL.g:3216:1: ruleNavigatingCommaArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingCommaArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3221:6: ( ruleNavigatingSemiArgCS )
                    {
                    // InternalEssentialOCL.g:3221:6: ( ruleNavigatingSemiArgCS )
                    // InternalEssentialOCL.g:3222:1: ruleNavigatingSemiArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingSemiArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3227:6: ( ruleNavigatingBarArgCS )
                    {
                    // InternalEssentialOCL.g:3227:6: ( ruleNavigatingBarArgCS )
                    // InternalEssentialOCL.g:3228:1: ruleNavigatingBarArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingBarArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives"
    // InternalEssentialOCL.g:3238:1: rule__NavigatingArgCS__Alternatives : ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) );
    public final void rule__NavigatingArgCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3242:1: ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) )
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( ((LA23_0>=RULE_INT && LA23_0<=RULE_ESCAPED_ID)||(LA23_0>=16 && LA23_0<=19)||(LA23_0>=40 && LA23_0<=54)||LA23_0==59||(LA23_0>=67 && LA23_0<=69)||LA23_0==74||(LA23_0>=79 && LA23_0<=80)||(LA23_0>=84 && LA23_0<=85)) ) {
                alt23=1;
            }
            else if ( (LA23_0==62) ) {
                alt23=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }
            switch (alt23) {
                case 1 :
                    // InternalEssentialOCL.g:3243:1: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3243:1: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    // InternalEssentialOCL.g:3244:1: ( rule__NavigatingArgCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0());
                    }
                    // InternalEssentialOCL.g:3245:1: ( rule__NavigatingArgCS__Group_0__0 )
                    // InternalEssentialOCL.g:3245:2: rule__NavigatingArgCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3249:6: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    {
                    // InternalEssentialOCL.g:3249:6: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    // InternalEssentialOCL.g:3250:1: ( rule__NavigatingArgCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_1());
                    }
                    // InternalEssentialOCL.g:3251:1: ( rule__NavigatingArgCS__Group_1__0 )
                    // InternalEssentialOCL.g:3251:2: rule__NavigatingArgCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1"
    // InternalEssentialOCL.g:3260:1: rule__NavigatingArgCS__Alternatives_0_1 : ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3264:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) )
            int alt24=3;
            switch ( input.LA(1) ) {
            case 55:
                {
                int LA24_1 = input.LA(2);

                if ( (synpred71_InternalEssentialOCL()) ) {
                    alt24=1;
                }
                else if ( (true) ) {
                    alt24=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 24, 1, input);

                    throw nvae;
                }
                }
                break;
            case 56:
                {
                int LA24_2 = input.LA(2);

                if ( (synpred71_InternalEssentialOCL()) ) {
                    alt24=1;
                }
                else if ( (true) ) {
                    alt24=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 24, 2, input);

                    throw nvae;
                }
                }
                break;
            case 62:
                {
                int LA24_3 = input.LA(2);

                if ( (synpred72_InternalEssentialOCL()) ) {
                    alt24=2;
                }
                else if ( (true) ) {
                    alt24=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 24, 3, input);

                    throw nvae;
                }
                }
                break;
            case 73:
                {
                alt24=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }

            switch (alt24) {
                case 1 :
                    // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    // InternalEssentialOCL.g:3266:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
                    }
                    // InternalEssentialOCL.g:3267:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    // InternalEssentialOCL.g:3267:2: rule__NavigatingArgCS__Group_0_1_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    {
                    // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    // InternalEssentialOCL.g:3272:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
                    }
                    // InternalEssentialOCL.g:3273:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    // InternalEssentialOCL.g:3273:2: rule__NavigatingArgCS__Group_0_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3277:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) )
                    {
                    // InternalEssentialOCL.g:3277:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) )
                    // InternalEssentialOCL.g:3278:1: ( rule__NavigatingArgCS__Group_0_1_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2());
                    }
                    // InternalEssentialOCL.g:3279:1: ( rule__NavigatingArgCS__Group_0_1_2__0 )
                    // InternalEssentialOCL.g:3279:2: rule__NavigatingArgCS__Group_0_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_0_0"
    // InternalEssentialOCL.g:3288:1: rule__NavigatingArgCS__Alternatives_0_1_0_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3292:1: ( ( 'with' ) | ( '<-' ) )
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==55) ) {
                alt25=1;
            }
            else if ( (LA25_0==56) ) {
                alt25=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }
            switch (alt25) {
                case 1 :
                    // InternalEssentialOCL.g:3293:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3293:1: ( 'with' )
                    // InternalEssentialOCL.g:3294:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_0_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_0_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3301:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3301:6: ( '<-' )
                    // InternalEssentialOCL.g:3302:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_0_0"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_1_2_0"
    // InternalEssentialOCL.g:3314:1: rule__NavigatingArgCS__Alternatives_0_1_1_2_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1_1_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3318:1: ( ( 'with' ) | ( '<-' ) )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==55) ) {
                alt26=1;
            }
            else if ( (LA26_0==56) ) {
                alt26=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }
            switch (alt26) {
                case 1 :
                    // InternalEssentialOCL.g:3319:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3319:1: ( 'with' )
                    // InternalEssentialOCL.g:3320:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_1_2_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_1_2_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3327:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3327:6: ( '<-' )
                    // InternalEssentialOCL.g:3328:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_1_2_0"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1_2_1_0"
    // InternalEssentialOCL.g:3340:1: rule__NavigatingArgCS__Alternatives_0_1_2_1_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3344:1: ( ( 'with' ) | ( '<-' ) )
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==55) ) {
                alt27=1;
            }
            else if ( (LA27_0==56) ) {
                alt27=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }
            switch (alt27) {
                case 1 :
                    // InternalEssentialOCL.g:3345:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3345:1: ( 'with' )
                    // InternalEssentialOCL.g:3346:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_2_1_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getWithKeyword_0_1_2_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3353:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3353:6: ( '<-' )
                    // InternalEssentialOCL.g:3354:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1_2_1_0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2"
    // InternalEssentialOCL.g:3366:1: rule__NavigatingCommaArgCS__Alternatives_2 : ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3370:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) )
            int alt28=3;
            switch ( input.LA(1) ) {
            case 55:
                {
                int LA28_1 = input.LA(2);

                if ( (synpred76_InternalEssentialOCL()) ) {
                    alt28=1;
                }
                else if ( (true) ) {
                    alt28=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 1, input);

                    throw nvae;
                }
                }
                break;
            case 56:
                {
                int LA28_2 = input.LA(2);

                if ( (synpred76_InternalEssentialOCL()) ) {
                    alt28=1;
                }
                else if ( (true) ) {
                    alt28=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 2, input);

                    throw nvae;
                }
                }
                break;
            case 62:
                {
                int LA28_3 = input.LA(2);

                if ( (synpred77_InternalEssentialOCL()) ) {
                    alt28=2;
                }
                else if ( (true) ) {
                    alt28=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 28, 3, input);

                    throw nvae;
                }
                }
                break;
            case 73:
                {
                alt28=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;
            }

            switch (alt28) {
                case 1 :
                    // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    {
                    // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    // InternalEssentialOCL.g:3372:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
                    }
                    // InternalEssentialOCL.g:3373:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    // InternalEssentialOCL.g:3373:2: rule__NavigatingCommaArgCS__Group_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    {
                    // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    // InternalEssentialOCL.g:3378:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
                    }
                    // InternalEssentialOCL.g:3379:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    // InternalEssentialOCL.g:3379:2: rule__NavigatingCommaArgCS__Group_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3383:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) )
                    {
                    // InternalEssentialOCL.g:3383:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) )
                    // InternalEssentialOCL.g:3384:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2());
                    }
                    // InternalEssentialOCL.g:3385:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 )
                    // InternalEssentialOCL.g:3385:2: rule__NavigatingCommaArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_0_0"
    // InternalEssentialOCL.g:3394:1: rule__NavigatingCommaArgCS__Alternatives_2_0_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3398:1: ( ( 'with' ) | ( '<-' ) )
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( (LA29_0==55) ) {
                alt29=1;
            }
            else if ( (LA29_0==56) ) {
                alt29=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }
            switch (alt29) {
                case 1 :
                    // InternalEssentialOCL.g:3399:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3399:1: ( 'with' )
                    // InternalEssentialOCL.g:3400:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_0_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_0_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3407:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3407:6: ( '<-' )
                    // InternalEssentialOCL.g:3408:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_0_0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_1_2_0"
    // InternalEssentialOCL.g:3420:1: rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2_1_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3424:1: ( ( 'with' ) | ( '<-' ) )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==55) ) {
                alt30=1;
            }
            else if ( (LA30_0==56) ) {
                alt30=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // InternalEssentialOCL.g:3425:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3425:1: ( 'with' )
                    // InternalEssentialOCL.g:3426:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_1_2_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_1_2_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3433:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3433:6: ( '<-' )
                    // InternalEssentialOCL.g:3434:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_1_2_0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2_2_1_0"
    // InternalEssentialOCL.g:3446:1: rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 : ( ( 'with' ) | ( '<-' ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3450:1: ( ( 'with' ) | ( '<-' ) )
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==55) ) {
                alt31=1;
            }
            else if ( (LA31_0==56) ) {
                alt31=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }
            switch (alt31) {
                case 1 :
                    // InternalEssentialOCL.g:3451:1: ( 'with' )
                    {
                    // InternalEssentialOCL.g:3451:1: ( 'with' )
                    // InternalEssentialOCL.g:3452:1: 'with'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_2_1_0_0());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getWithKeyword_2_2_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3459:6: ( '<-' )
                    {
                    // InternalEssentialOCL.g:3459:6: ( '<-' )
                    // InternalEssentialOCL.g:3460:1: '<-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0_1());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2_2_1_0"


    // $ANTLR start "rule__IfExpCS__OwnedConditionAlternatives_1_0"
    // InternalEssentialOCL.g:3472:1: rule__IfExpCS__OwnedConditionAlternatives_1_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__IfExpCS__OwnedConditionAlternatives_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3476:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt32=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 16:
            case 17:
            case 18:
            case 19:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 59:
            case 67:
            case 68:
            case 69:
            case 74:
            case 79:
            case 80:
            case 84:
            case 85:
                {
                alt32=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA32_2 = input.LA(2);

                if ( (LA32_2==16||(LA32_2>=19 && LA32_2<=39)||LA32_2==59||LA32_2==63||LA32_2==71||LA32_2==75||LA32_2==81||LA32_2==86) ) {
                    alt32=1;
                }
                else if ( (LA32_2==62) ) {
                    alt32=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 32, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA32_3 = input.LA(2);

                if ( (LA32_3==62) ) {
                    alt32=2;
                }
                else if ( (LA32_3==16||(LA32_3>=19 && LA32_3<=39)||LA32_3==59||LA32_3==63||LA32_3==71||LA32_3==75||LA32_3==81||LA32_3==86) ) {
                    alt32=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 32, 3, input);

                    throw nvae;
                }
                }
                break;
            case 62:
                {
                alt32=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 32, 0, input);

                throw nvae;
            }

            switch (alt32) {
                case 1 :
                    // InternalEssentialOCL.g:3477:1: ( ruleExpCS )
                    {
                    // InternalEssentialOCL.g:3477:1: ( ruleExpCS )
                    // InternalEssentialOCL.g:3478:1: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3483:6: ( rulePatternExpCS )
                    {
                    // InternalEssentialOCL.g:3483:6: ( rulePatternExpCS )
                    // InternalEssentialOCL.g:3484:1: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePatternExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedConditionAlternatives_1_0"


    // $ANTLR start "rule__MultiplicityCS__Alternatives_1"
    // InternalEssentialOCL.g:3494:1: rule__MultiplicityCS__Alternatives_1 : ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) );
    public final void rule__MultiplicityCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3498:1: ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) )
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==RULE_INT) ) {
                alt33=1;
            }
            else if ( (LA33_0==19||LA33_0==21||LA33_0==58) ) {
                alt33=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                throw nvae;
            }
            switch (alt33) {
                case 1 :
                    // InternalEssentialOCL.g:3499:1: ( ruleMultiplicityBoundsCS )
                    {
                    // InternalEssentialOCL.g:3499:1: ( ruleMultiplicityBoundsCS )
                    // InternalEssentialOCL.g:3500:1: ruleMultiplicityBoundsCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMultiplicityBoundsCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3505:6: ( ruleMultiplicityStringCS )
                    {
                    // InternalEssentialOCL.g:3505:6: ( ruleMultiplicityStringCS )
                    // InternalEssentialOCL.g:3506:1: ruleMultiplicityStringCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMultiplicityStringCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Alternatives_1"


    // $ANTLR start "rule__MultiplicityCS__Alternatives_2"
    // InternalEssentialOCL.g:3516:1: rule__MultiplicityCS__Alternatives_2 : ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) );
    public final void rule__MultiplicityCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3520:1: ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) )
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==57) ) {
                alt34=1;
            }
            else if ( (LA34_0==89) ) {
                alt34=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 34, 0, input);

                throw nvae;
            }
            switch (alt34) {
                case 1 :
                    // InternalEssentialOCL.g:3521:1: ( '|?' )
                    {
                    // InternalEssentialOCL.g:3521:1: ( '|?' )
                    // InternalEssentialOCL.g:3522:1: '|?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0());
                    }
                    match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3529:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    {
                    // InternalEssentialOCL.g:3529:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    // InternalEssentialOCL.g:3530:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1());
                    }
                    // InternalEssentialOCL.g:3531:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    // InternalEssentialOCL.g:3531:2: rule__MultiplicityCS__IsNullFreeAssignment_2_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityCS__IsNullFreeAssignment_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Alternatives_2"


    // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAlternatives_0"
    // InternalEssentialOCL.g:3540:1: rule__MultiplicityStringCS__StringBoundsAlternatives_0 : ( ( '*' ) | ( '+' ) | ( '?' ) );
    public final void rule__MultiplicityStringCS__StringBoundsAlternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3544:1: ( ( '*' ) | ( '+' ) | ( '?' ) )
            int alt35=3;
            switch ( input.LA(1) ) {
            case 19:
                {
                alt35=1;
                }
                break;
            case 21:
                {
                alt35=2;
                }
                break;
            case 58:
                {
                alt35=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                throw nvae;
            }

            switch (alt35) {
                case 1 :
                    // InternalEssentialOCL.g:3545:1: ( '*' )
                    {
                    // InternalEssentialOCL.g:3545:1: ( '*' )
                    // InternalEssentialOCL.g:3546:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0());
                    }
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3553:6: ( '+' )
                    {
                    // InternalEssentialOCL.g:3553:6: ( '+' )
                    // InternalEssentialOCL.g:3554:1: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1());
                    }
                    match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEssentialOCL.g:3561:6: ( '?' )
                    {
                    // InternalEssentialOCL.g:3561:6: ( '?' )
                    // InternalEssentialOCL.g:3562:1: '?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2());
                    }
                    match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAlternatives_0"


    // $ANTLR start "rule__TypeRefCS__Alternatives"
    // InternalEssentialOCL.g:3574:1: rule__TypeRefCS__Alternatives : ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) );
    public final void rule__TypeRefCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3578:1: ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) )
            int alt36=2;
            int LA36_0 = input.LA(1);

            if ( ((LA36_0>=RULE_SIMPLE_ID && LA36_0<=RULE_ESCAPED_ID)) ) {
                alt36=1;
            }
            else if ( (LA36_0==58) ) {
                alt36=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 36, 0, input);

                throw nvae;
            }
            switch (alt36) {
                case 1 :
                    // InternalEssentialOCL.g:3579:1: ( ruleTypedRefCS )
                    {
                    // InternalEssentialOCL.g:3579:1: ( ruleTypedRefCS )
                    // InternalEssentialOCL.g:3580:1: ruleTypedRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypedRefCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3585:6: ( ruleWildcardTypeRefCS )
                    {
                    // InternalEssentialOCL.g:3585:6: ( ruleWildcardTypeRefCS )
                    // InternalEssentialOCL.g:3586:1: ruleWildcardTypeRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleWildcardTypeRefCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeRefCS__Alternatives"


    // $ANTLR start "rule__ID__Alternatives"
    // InternalEssentialOCL.g:3596:1: rule__ID__Alternatives : ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) );
    public final void rule__ID__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3600:1: ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) )
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( (LA37_0==RULE_SIMPLE_ID) ) {
                alt37=1;
            }
            else if ( (LA37_0==RULE_ESCAPED_ID) ) {
                alt37=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 37, 0, input);

                throw nvae;
            }
            switch (alt37) {
                case 1 :
                    // InternalEssentialOCL.g:3601:1: ( RULE_SIMPLE_ID )
                    {
                    // InternalEssentialOCL.g:3601:1: ( RULE_SIMPLE_ID )
                    // InternalEssentialOCL.g:3602:1: RULE_SIMPLE_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0());
                    }
                    match(input,RULE_SIMPLE_ID,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3607:6: ( RULE_ESCAPED_ID )
                    {
                    // InternalEssentialOCL.g:3607:6: ( RULE_ESCAPED_ID )
                    // InternalEssentialOCL.g:3608:1: RULE_ESCAPED_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1());
                    }
                    match(input,RULE_ESCAPED_ID,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ID__Alternatives"


    // $ANTLR start "rule__UPPER__Alternatives"
    // InternalEssentialOCL.g:3618:1: rule__UPPER__Alternatives : ( ( RULE_INT ) | ( '*' ) );
    public final void rule__UPPER__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3622:1: ( ( RULE_INT ) | ( '*' ) )
            int alt38=2;
            int LA38_0 = input.LA(1);

            if ( (LA38_0==RULE_INT) ) {
                alt38=1;
            }
            else if ( (LA38_0==19) ) {
                alt38=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 38, 0, input);

                throw nvae;
            }
            switch (alt38) {
                case 1 :
                    // InternalEssentialOCL.g:3623:1: ( RULE_INT )
                    {
                    // InternalEssentialOCL.g:3623:1: ( RULE_INT )
                    // InternalEssentialOCL.g:3624:1: RULE_INT
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0());
                    }
                    match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEssentialOCL.g:3629:6: ( '*' )
                    {
                    // InternalEssentialOCL.g:3629:6: ( '*' )
                    // InternalEssentialOCL.g:3630:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getAsteriskKeyword_1());
                    }
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getUPPERAccess().getAsteriskKeyword_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UPPER__Alternatives"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0"
    // InternalEssentialOCL.g:3646:1: rule__URIFirstPathElementCS__Group_1__0 : rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 ;
    public final void rule__URIFirstPathElementCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3650:1: ( rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 )
            // InternalEssentialOCL.g:3651:2: rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_4);
            rule__URIFirstPathElementCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:3658:1: rule__URIFirstPathElementCS__Group_1__0__Impl : ( () ) ;
    public final void rule__URIFirstPathElementCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3662:1: ( ( () ) )
            // InternalEssentialOCL.g:3663:1: ( () )
            {
            // InternalEssentialOCL.g:3663:1: ( () )
            // InternalEssentialOCL.g:3664:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0());
            }
            // InternalEssentialOCL.g:3665:1: ()
            // InternalEssentialOCL.g:3667:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0__Impl"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1"
    // InternalEssentialOCL.g:3677:1: rule__URIFirstPathElementCS__Group_1__1 : rule__URIFirstPathElementCS__Group_1__1__Impl ;
    public final void rule__URIFirstPathElementCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3681:1: ( rule__URIFirstPathElementCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:3682:2: rule__URIFirstPathElementCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__1"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:3688:1: rule__URIFirstPathElementCS__Group_1__1__Impl : ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) ;
    public final void rule__URIFirstPathElementCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3692:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:3693:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:3693:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            // InternalEssentialOCL.g:3694:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1());
            }
            // InternalEssentialOCL.g:3695:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            // InternalEssentialOCL.g:3695:2: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__ReferredElementAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group__0"
    // InternalEssentialOCL.g:3709:1: rule__CollectionTypeCS__Group__0 : rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 ;
    public final void rule__CollectionTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3713:1: ( rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 )
            // InternalEssentialOCL.g:3714:2: rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__CollectionTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__0"


    // $ANTLR start "rule__CollectionTypeCS__Group__0__Impl"
    // InternalEssentialOCL.g:3721:1: rule__CollectionTypeCS__Group__0__Impl : ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) ;
    public final void rule__CollectionTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3725:1: ( ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:3726:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:3726:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:3727:1: ( rule__CollectionTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:3728:1: ( rule__CollectionTypeCS__NameAssignment_0 )
            // InternalEssentialOCL.g:3728:2: rule__CollectionTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group__1"
    // InternalEssentialOCL.g:3738:1: rule__CollectionTypeCS__Group__1 : rule__CollectionTypeCS__Group__1__Impl ;
    public final void rule__CollectionTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3742:1: ( rule__CollectionTypeCS__Group__1__Impl )
            // InternalEssentialOCL.g:3743:2: rule__CollectionTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__1"


    // $ANTLR start "rule__CollectionTypeCS__Group__1__Impl"
    // InternalEssentialOCL.g:3749:1: rule__CollectionTypeCS__Group__1__Impl : ( ( rule__CollectionTypeCS__Group_1__0 )? ) ;
    public final void rule__CollectionTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3753:1: ( ( ( rule__CollectionTypeCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:3754:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:3754:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            // InternalEssentialOCL.g:3755:1: ( rule__CollectionTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:3756:1: ( rule__CollectionTypeCS__Group_1__0 )?
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( (LA39_0==59) ) {
                alt39=1;
            }
            switch (alt39) {
                case 1 :
                    // InternalEssentialOCL.g:3756:2: rule__CollectionTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__0"
    // InternalEssentialOCL.g:3770:1: rule__CollectionTypeCS__Group_1__0 : rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 ;
    public final void rule__CollectionTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3774:1: ( rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 )
            // InternalEssentialOCL.g:3775:2: rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__CollectionTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__0"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:3782:1: rule__CollectionTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__CollectionTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3786:1: ( ( '(' ) )
            // InternalEssentialOCL.g:3787:1: ( '(' )
            {
            // InternalEssentialOCL.g:3787:1: ( '(' )
            // InternalEssentialOCL.g:3788:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__1"
    // InternalEssentialOCL.g:3801:1: rule__CollectionTypeCS__Group_1__1 : rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 ;
    public final void rule__CollectionTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3805:1: ( rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 )
            // InternalEssentialOCL.g:3806:2: rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_7);
            rule__CollectionTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__1"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:3813:1: rule__CollectionTypeCS__Group_1__1__Impl : ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__CollectionTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3817:1: ( ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:3818:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:3818:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            // InternalEssentialOCL.g:3819:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalEssentialOCL.g:3820:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            // InternalEssentialOCL.g:3820:2: rule__CollectionTypeCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__2"
    // InternalEssentialOCL.g:3830:1: rule__CollectionTypeCS__Group_1__2 : rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 ;
    public final void rule__CollectionTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3834:1: ( rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 )
            // InternalEssentialOCL.g:3835:2: rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3
            {
            pushFollow(FollowSets000.FOLLOW_7);
            rule__CollectionTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__2"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__2__Impl"
    // InternalEssentialOCL.g:3842:1: rule__CollectionTypeCS__Group_1__2__Impl : ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) ;
    public final void rule__CollectionTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3846:1: ( ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) )
            // InternalEssentialOCL.g:3847:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? )
            {
            // InternalEssentialOCL.g:3847:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? )
            // InternalEssentialOCL.g:3848:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2());
            }
            // InternalEssentialOCL.g:3849:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )?
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( (LA40_0==71) ) {
                alt40=1;
            }
            switch (alt40) {
                case 1 :
                    // InternalEssentialOCL.g:3849:2: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__3"
    // InternalEssentialOCL.g:3859:1: rule__CollectionTypeCS__Group_1__3 : rule__CollectionTypeCS__Group_1__3__Impl ;
    public final void rule__CollectionTypeCS__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3863:1: ( rule__CollectionTypeCS__Group_1__3__Impl )
            // InternalEssentialOCL.g:3864:2: rule__CollectionTypeCS__Group_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__3"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__3__Impl"
    // InternalEssentialOCL.g:3870:1: rule__CollectionTypeCS__Group_1__3__Impl : ( ')' ) ;
    public final void rule__CollectionTypeCS__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3874:1: ( ( ')' ) )
            // InternalEssentialOCL.g:3875:1: ( ')' )
            {
            // InternalEssentialOCL.g:3875:1: ( ')' )
            // InternalEssentialOCL.g:3876:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__3__Impl"


    // $ANTLR start "rule__MapTypeCS__Group__0"
    // InternalEssentialOCL.g:3897:1: rule__MapTypeCS__Group__0 : rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 ;
    public final void rule__MapTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3901:1: ( rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 )
            // InternalEssentialOCL.g:3902:2: rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__MapTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__0"


    // $ANTLR start "rule__MapTypeCS__Group__0__Impl"
    // InternalEssentialOCL.g:3909:1: rule__MapTypeCS__Group__0__Impl : ( ( rule__MapTypeCS__NameAssignment_0 ) ) ;
    public final void rule__MapTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3913:1: ( ( ( rule__MapTypeCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:3914:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:3914:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:3915:1: ( rule__MapTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:3916:1: ( rule__MapTypeCS__NameAssignment_0 )
            // InternalEssentialOCL.g:3916:2: rule__MapTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__0__Impl"


    // $ANTLR start "rule__MapTypeCS__Group__1"
    // InternalEssentialOCL.g:3926:1: rule__MapTypeCS__Group__1 : rule__MapTypeCS__Group__1__Impl ;
    public final void rule__MapTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3930:1: ( rule__MapTypeCS__Group__1__Impl )
            // InternalEssentialOCL.g:3931:2: rule__MapTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__1"


    // $ANTLR start "rule__MapTypeCS__Group__1__Impl"
    // InternalEssentialOCL.g:3937:1: rule__MapTypeCS__Group__1__Impl : ( ( rule__MapTypeCS__Group_1__0 )? ) ;
    public final void rule__MapTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3941:1: ( ( ( rule__MapTypeCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:3942:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:3942:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            // InternalEssentialOCL.g:3943:1: ( rule__MapTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:3944:1: ( rule__MapTypeCS__Group_1__0 )?
            int alt41=2;
            int LA41_0 = input.LA(1);

            if ( (LA41_0==59) ) {
                alt41=1;
            }
            switch (alt41) {
                case 1 :
                    // InternalEssentialOCL.g:3944:2: rule__MapTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MapTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__1__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__0"
    // InternalEssentialOCL.g:3958:1: rule__MapTypeCS__Group_1__0 : rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 ;
    public final void rule__MapTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3962:1: ( rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 )
            // InternalEssentialOCL.g:3963:2: rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__MapTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__0"


    // $ANTLR start "rule__MapTypeCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:3970:1: rule__MapTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__MapTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3974:1: ( ( '(' ) )
            // InternalEssentialOCL.g:3975:1: ( '(' )
            {
            // InternalEssentialOCL.g:3975:1: ( '(' )
            // InternalEssentialOCL.g:3976:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__1"
    // InternalEssentialOCL.g:3989:1: rule__MapTypeCS__Group_1__1 : rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 ;
    public final void rule__MapTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:3993:1: ( rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 )
            // InternalEssentialOCL.g:3994:2: rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__MapTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__1"


    // $ANTLR start "rule__MapTypeCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:4001:1: rule__MapTypeCS__Group_1__1__Impl : ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) ;
    public final void rule__MapTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4005:1: ( ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:4006:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:4006:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            // InternalEssentialOCL.g:4007:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1());
            }
            // InternalEssentialOCL.g:4008:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            // InternalEssentialOCL.g:4008:2: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__OwnedKeyTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__2"
    // InternalEssentialOCL.g:4018:1: rule__MapTypeCS__Group_1__2 : rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 ;
    public final void rule__MapTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4022:1: ( rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 )
            // InternalEssentialOCL.g:4023:2: rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__MapTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__2"


    // $ANTLR start "rule__MapTypeCS__Group_1__2__Impl"
    // InternalEssentialOCL.g:4030:1: rule__MapTypeCS__Group_1__2__Impl : ( ',' ) ;
    public final void rule__MapTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4034:1: ( ( ',' ) )
            // InternalEssentialOCL.g:4035:1: ( ',' )
            {
            // InternalEssentialOCL.g:4035:1: ( ',' )
            // InternalEssentialOCL.g:4036:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__3"
    // InternalEssentialOCL.g:4049:1: rule__MapTypeCS__Group_1__3 : rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 ;
    public final void rule__MapTypeCS__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4053:1: ( rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 )
            // InternalEssentialOCL.g:4054:2: rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__MapTypeCS__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__3"


    // $ANTLR start "rule__MapTypeCS__Group_1__3__Impl"
    // InternalEssentialOCL.g:4061:1: rule__MapTypeCS__Group_1__3__Impl : ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) ;
    public final void rule__MapTypeCS__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4065:1: ( ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) )
            // InternalEssentialOCL.g:4066:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            {
            // InternalEssentialOCL.g:4066:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            // InternalEssentialOCL.g:4067:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3());
            }
            // InternalEssentialOCL.g:4068:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            // InternalEssentialOCL.g:4068:2: rule__MapTypeCS__OwnedValueTypeAssignment_1_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__OwnedValueTypeAssignment_1_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__3__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__4"
    // InternalEssentialOCL.g:4078:1: rule__MapTypeCS__Group_1__4 : rule__MapTypeCS__Group_1__4__Impl ;
    public final void rule__MapTypeCS__Group_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4082:1: ( rule__MapTypeCS__Group_1__4__Impl )
            // InternalEssentialOCL.g:4083:2: rule__MapTypeCS__Group_1__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__4"


    // $ANTLR start "rule__MapTypeCS__Group_1__4__Impl"
    // InternalEssentialOCL.g:4089:1: rule__MapTypeCS__Group_1__4__Impl : ( ')' ) ;
    public final void rule__MapTypeCS__Group_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4093:1: ( ( ')' ) )
            // InternalEssentialOCL.g:4094:1: ( ')' )
            {
            // InternalEssentialOCL.g:4094:1: ( ')' )
            // InternalEssentialOCL.g:4095:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__4__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group__0"
    // InternalEssentialOCL.g:4118:1: rule__TupleTypeCS__Group__0 : rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 ;
    public final void rule__TupleTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4122:1: ( rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 )
            // InternalEssentialOCL.g:4123:2: rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TupleTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__0"


    // $ANTLR start "rule__TupleTypeCS__Group__0__Impl"
    // InternalEssentialOCL.g:4130:1: rule__TupleTypeCS__Group__0__Impl : ( ( rule__TupleTypeCS__NameAssignment_0 ) ) ;
    public final void rule__TupleTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4134:1: ( ( ( rule__TupleTypeCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:4135:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:4135:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:4136:1: ( rule__TupleTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:4137:1: ( rule__TupleTypeCS__NameAssignment_0 )
            // InternalEssentialOCL.g:4137:2: rule__TupleTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group__1"
    // InternalEssentialOCL.g:4147:1: rule__TupleTypeCS__Group__1 : rule__TupleTypeCS__Group__1__Impl ;
    public final void rule__TupleTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4151:1: ( rule__TupleTypeCS__Group__1__Impl )
            // InternalEssentialOCL.g:4152:2: rule__TupleTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__1"


    // $ANTLR start "rule__TupleTypeCS__Group__1__Impl"
    // InternalEssentialOCL.g:4158:1: rule__TupleTypeCS__Group__1__Impl : ( ( rule__TupleTypeCS__Group_1__0 )? ) ;
    public final void rule__TupleTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4162:1: ( ( ( rule__TupleTypeCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:4163:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:4163:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            // InternalEssentialOCL.g:4164:1: ( rule__TupleTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:4165:1: ( rule__TupleTypeCS__Group_1__0 )?
            int alt42=2;
            int LA42_0 = input.LA(1);

            if ( (LA42_0==59) ) {
                alt42=1;
            }
            switch (alt42) {
                case 1 :
                    // InternalEssentialOCL.g:4165:2: rule__TupleTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__0"
    // InternalEssentialOCL.g:4179:1: rule__TupleTypeCS__Group_1__0 : rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 ;
    public final void rule__TupleTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4183:1: ( rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 )
            // InternalEssentialOCL.g:4184:2: rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__TupleTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:4191:1: rule__TupleTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TupleTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4195:1: ( ( '(' ) )
            // InternalEssentialOCL.g:4196:1: ( '(' )
            {
            // InternalEssentialOCL.g:4196:1: ( '(' )
            // InternalEssentialOCL.g:4197:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__1"
    // InternalEssentialOCL.g:4210:1: rule__TupleTypeCS__Group_1__1 : rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 ;
    public final void rule__TupleTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4214:1: ( rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 )
            // InternalEssentialOCL.g:4215:2: rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__TupleTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:4222:1: rule__TupleTypeCS__Group_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1__0 )? ) ;
    public final void rule__TupleTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4226:1: ( ( ( rule__TupleTypeCS__Group_1_1__0 )? ) )
            // InternalEssentialOCL.g:4227:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            {
            // InternalEssentialOCL.g:4227:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            // InternalEssentialOCL.g:4228:1: ( rule__TupleTypeCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1());
            }
            // InternalEssentialOCL.g:4229:1: ( rule__TupleTypeCS__Group_1_1__0 )?
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( ((LA43_0>=RULE_SIMPLE_ID && LA43_0<=RULE_ESCAPED_ID)) ) {
                alt43=1;
            }
            switch (alt43) {
                case 1 :
                    // InternalEssentialOCL.g:4229:2: rule__TupleTypeCS__Group_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleTypeCS__Group_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__2"
    // InternalEssentialOCL.g:4239:1: rule__TupleTypeCS__Group_1__2 : rule__TupleTypeCS__Group_1__2__Impl ;
    public final void rule__TupleTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4243:1: ( rule__TupleTypeCS__Group_1__2__Impl )
            // InternalEssentialOCL.g:4244:2: rule__TupleTypeCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__2"


    // $ANTLR start "rule__TupleTypeCS__Group_1__2__Impl"
    // InternalEssentialOCL.g:4250:1: rule__TupleTypeCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TupleTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4254:1: ( ( ')' ) )
            // InternalEssentialOCL.g:4255:1: ( ')' )
            {
            // InternalEssentialOCL.g:4255:1: ( ')' )
            // InternalEssentialOCL.g:4256:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__0"
    // InternalEssentialOCL.g:4275:1: rule__TupleTypeCS__Group_1_1__0 : rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 ;
    public final void rule__TupleTypeCS__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4279:1: ( rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 )
            // InternalEssentialOCL.g:4280:2: rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__TupleTypeCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__0__Impl"
    // InternalEssentialOCL.g:4287:1: rule__TupleTypeCS__Group_1_1__0__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) ;
    public final void rule__TupleTypeCS__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4291:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) )
            // InternalEssentialOCL.g:4292:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            {
            // InternalEssentialOCL.g:4292:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            // InternalEssentialOCL.g:4293:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0());
            }
            // InternalEssentialOCL.g:4294:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            // InternalEssentialOCL.g:4294:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__OwnedPartsAssignment_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__1"
    // InternalEssentialOCL.g:4304:1: rule__TupleTypeCS__Group_1_1__1 : rule__TupleTypeCS__Group_1_1__1__Impl ;
    public final void rule__TupleTypeCS__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4308:1: ( rule__TupleTypeCS__Group_1_1__1__Impl )
            // InternalEssentialOCL.g:4309:2: rule__TupleTypeCS__Group_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__1__Impl"
    // InternalEssentialOCL.g:4315:1: rule__TupleTypeCS__Group_1_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) ;
    public final void rule__TupleTypeCS__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4319:1: ( ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) )
            // InternalEssentialOCL.g:4320:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            {
            // InternalEssentialOCL.g:4320:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            // InternalEssentialOCL.g:4321:1: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1());
            }
            // InternalEssentialOCL.g:4322:1: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            loop44:
            do {
                int alt44=2;
                int LA44_0 = input.LA(1);

                if ( (LA44_0==61) ) {
                    alt44=1;
                }


                switch (alt44) {
            	case 1 :
            	    // InternalEssentialOCL.g:4322:2: rule__TupleTypeCS__Group_1_1_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__TupleTypeCS__Group_1_1_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0"
    // InternalEssentialOCL.g:4336:1: rule__TupleTypeCS__Group_1_1_1__0 : rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 ;
    public final void rule__TupleTypeCS__Group_1_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4340:1: ( rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 )
            // InternalEssentialOCL.g:4341:2: rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TupleTypeCS__Group_1_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0__Impl"
    // InternalEssentialOCL.g:4348:1: rule__TupleTypeCS__Group_1_1_1__0__Impl : ( ',' ) ;
    public final void rule__TupleTypeCS__Group_1_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4352:1: ( ( ',' ) )
            // InternalEssentialOCL.g:4353:1: ( ',' )
            {
            // InternalEssentialOCL.g:4353:1: ( ',' )
            // InternalEssentialOCL.g:4354:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1"
    // InternalEssentialOCL.g:4367:1: rule__TupleTypeCS__Group_1_1_1__1 : rule__TupleTypeCS__Group_1_1_1__1__Impl ;
    public final void rule__TupleTypeCS__Group_1_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4371:1: ( rule__TupleTypeCS__Group_1_1_1__1__Impl )
            // InternalEssentialOCL.g:4372:2: rule__TupleTypeCS__Group_1_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1__Impl"
    // InternalEssentialOCL.g:4378:1: rule__TupleTypeCS__Group_1_1_1__1__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) ;
    public final void rule__TupleTypeCS__Group_1_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4382:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) )
            // InternalEssentialOCL.g:4383:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            {
            // InternalEssentialOCL.g:4383:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            // InternalEssentialOCL.g:4384:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1());
            }
            // InternalEssentialOCL.g:4385:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            // InternalEssentialOCL.g:4385:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__1__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__0"
    // InternalEssentialOCL.g:4399:1: rule__TuplePartCS__Group__0 : rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 ;
    public final void rule__TuplePartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4403:1: ( rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 )
            // InternalEssentialOCL.g:4404:2: rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_13);
            rule__TuplePartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__0"


    // $ANTLR start "rule__TuplePartCS__Group__0__Impl"
    // InternalEssentialOCL.g:4411:1: rule__TuplePartCS__Group__0__Impl : ( ( rule__TuplePartCS__NameAssignment_0 ) ) ;
    public final void rule__TuplePartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4415:1: ( ( ( rule__TuplePartCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:4416:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:4416:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:4417:1: ( rule__TuplePartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:4418:1: ( rule__TuplePartCS__NameAssignment_0 )
            // InternalEssentialOCL.g:4418:2: rule__TuplePartCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__0__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__1"
    // InternalEssentialOCL.g:4428:1: rule__TuplePartCS__Group__1 : rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 ;
    public final void rule__TuplePartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4432:1: ( rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 )
            // InternalEssentialOCL.g:4433:2: rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__TuplePartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__1"


    // $ANTLR start "rule__TuplePartCS__Group__1__Impl"
    // InternalEssentialOCL.g:4440:1: rule__TuplePartCS__Group__1__Impl : ( ':' ) ;
    public final void rule__TuplePartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4444:1: ( ( ':' ) )
            // InternalEssentialOCL.g:4445:1: ( ':' )
            {
            // InternalEssentialOCL.g:4445:1: ( ':' )
            // InternalEssentialOCL.g:4446:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getColonKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getColonKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__1__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__2"
    // InternalEssentialOCL.g:4459:1: rule__TuplePartCS__Group__2 : rule__TuplePartCS__Group__2__Impl ;
    public final void rule__TuplePartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4463:1: ( rule__TuplePartCS__Group__2__Impl )
            // InternalEssentialOCL.g:4464:2: rule__TuplePartCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__2"


    // $ANTLR start "rule__TuplePartCS__Group__2__Impl"
    // InternalEssentialOCL.g:4470:1: rule__TuplePartCS__Group__2__Impl : ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) ;
    public final void rule__TuplePartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4474:1: ( ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) )
            // InternalEssentialOCL.g:4475:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            {
            // InternalEssentialOCL.g:4475:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            // InternalEssentialOCL.g:4476:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2());
            }
            // InternalEssentialOCL.g:4477:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            // InternalEssentialOCL.g:4477:2: rule__TuplePartCS__OwnedTypeAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__OwnedTypeAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:4493:1: rule__CollectionLiteralExpCS__Group__0 : rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 ;
    public final void rule__CollectionLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4497:1: ( rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:4498:2: rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__CollectionLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:4505:1: rule__CollectionLiteralExpCS__Group__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4509:1: ( ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalEssentialOCL.g:4510:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEssentialOCL.g:4510:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalEssentialOCL.g:4511:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalEssentialOCL.g:4512:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalEssentialOCL.g:4512:2: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:4522:1: rule__CollectionLiteralExpCS__Group__1 : rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 ;
    public final void rule__CollectionLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4526:1: ( rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 )
            // InternalEssentialOCL.g:4527:2: rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__CollectionLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:4534:1: rule__CollectionLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4538:1: ( ( '{' ) )
            // InternalEssentialOCL.g:4539:1: ( '{' )
            {
            // InternalEssentialOCL.g:4539:1: ( '{' )
            // InternalEssentialOCL.g:4540:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__2"
    // InternalEssentialOCL.g:4553:1: rule__CollectionLiteralExpCS__Group__2 : rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 ;
    public final void rule__CollectionLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4557:1: ( rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 )
            // InternalEssentialOCL.g:4558:2: rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__CollectionLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__2"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:4565:1: rule__CollectionLiteralExpCS__Group__2__Impl : ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) ;
    public final void rule__CollectionLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4569:1: ( ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:4570:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:4570:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            // InternalEssentialOCL.g:4571:1: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:4572:1: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            int alt45=2;
            int LA45_0 = input.LA(1);

            if ( ((LA45_0>=RULE_INT && LA45_0<=RULE_ESCAPED_ID)||(LA45_0>=16 && LA45_0<=19)||(LA45_0>=40 && LA45_0<=54)||LA45_0==59||LA45_0==62||(LA45_0>=67 && LA45_0<=69)||LA45_0==74||(LA45_0>=79 && LA45_0<=80)||(LA45_0>=84 && LA45_0<=85)) ) {
                alt45=1;
            }
            switch (alt45) {
                case 1 :
                    // InternalEssentialOCL.g:4572:2: rule__CollectionLiteralExpCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralExpCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__3"
    // InternalEssentialOCL.g:4582:1: rule__CollectionLiteralExpCS__Group__3 : rule__CollectionLiteralExpCS__Group__3__Impl ;
    public final void rule__CollectionLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4586:1: ( rule__CollectionLiteralExpCS__Group__3__Impl )
            // InternalEssentialOCL.g:4587:2: rule__CollectionLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__3"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:4593:1: rule__CollectionLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4597:1: ( ( '}' ) )
            // InternalEssentialOCL.g:4598:1: ( '}' )
            {
            // InternalEssentialOCL.g:4598:1: ( '}' )
            // InternalEssentialOCL.g:4599:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0"
    // InternalEssentialOCL.g:4620:1: rule__CollectionLiteralExpCS__Group_2__0 : rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 ;
    public final void rule__CollectionLiteralExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4624:1: ( rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 )
            // InternalEssentialOCL.g:4625:2: rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__CollectionLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:4632:1: rule__CollectionLiteralExpCS__Group_2__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4636:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEssentialOCL.g:4637:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEssentialOCL.g:4637:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalEssentialOCL.g:4638:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalEssentialOCL.g:4639:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalEssentialOCL.g:4639:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1"
    // InternalEssentialOCL.g:4649:1: rule__CollectionLiteralExpCS__Group_2__1 : rule__CollectionLiteralExpCS__Group_2__1__Impl ;
    public final void rule__CollectionLiteralExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4653:1: ( rule__CollectionLiteralExpCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:4654:2: rule__CollectionLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:4660:1: rule__CollectionLiteralExpCS__Group_2__1__Impl : ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) ;
    public final void rule__CollectionLiteralExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4664:1: ( ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) )
            // InternalEssentialOCL.g:4665:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalEssentialOCL.g:4665:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            // InternalEssentialOCL.g:4666:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1());
            }
            // InternalEssentialOCL.g:4667:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            loop46:
            do {
                int alt46=2;
                int LA46_0 = input.LA(1);

                if ( (LA46_0==61) ) {
                    alt46=1;
                }


                switch (alt46) {
            	case 1 :
            	    // InternalEssentialOCL.g:4667:2: rule__CollectionLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__CollectionLiteralExpCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0"
    // InternalEssentialOCL.g:4681:1: rule__CollectionLiteralExpCS__Group_2_1__0 : rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4685:1: ( rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 )
            // InternalEssentialOCL.g:4686:2: rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_16);
            rule__CollectionLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0__Impl"
    // InternalEssentialOCL.g:4693:1: rule__CollectionLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4697:1: ( ( ',' ) )
            // InternalEssentialOCL.g:4698:1: ( ',' )
            {
            // InternalEssentialOCL.g:4698:1: ( ',' )
            // InternalEssentialOCL.g:4699:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1"
    // InternalEssentialOCL.g:4712:1: rule__CollectionLiteralExpCS__Group_2_1__1 : rule__CollectionLiteralExpCS__Group_2_1__1__Impl ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4716:1: ( rule__CollectionLiteralExpCS__Group_2_1__1__Impl )
            // InternalEssentialOCL.g:4717:2: rule__CollectionLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1__Impl"
    // InternalEssentialOCL.g:4723:1: rule__CollectionLiteralExpCS__Group_2_1__1__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4727:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEssentialOCL.g:4728:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEssentialOCL.g:4728:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEssentialOCL.g:4729:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalEssentialOCL.g:4730:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalEssentialOCL.g:4730:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0"
    // InternalEssentialOCL.g:4744:1: rule__CollectionLiteralPartCS__Group_0__0 : rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 ;
    public final void rule__CollectionLiteralPartCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4748:1: ( rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 )
            // InternalEssentialOCL.g:4749:2: rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__CollectionLiteralPartCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:4756:1: rule__CollectionLiteralPartCS__Group_0__0__Impl : ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4760:1: ( ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) )
            // InternalEssentialOCL.g:4761:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            {
            // InternalEssentialOCL.g:4761:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            // InternalEssentialOCL.g:4762:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0());
            }
            // InternalEssentialOCL.g:4763:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            // InternalEssentialOCL.g:4763:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1"
    // InternalEssentialOCL.g:4773:1: rule__CollectionLiteralPartCS__Group_0__1 : rule__CollectionLiteralPartCS__Group_0__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4777:1: ( rule__CollectionLiteralPartCS__Group_0__1__Impl )
            // InternalEssentialOCL.g:4778:2: rule__CollectionLiteralPartCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:4784:1: rule__CollectionLiteralPartCS__Group_0__1__Impl : ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) ;
    public final void rule__CollectionLiteralPartCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4788:1: ( ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) )
            // InternalEssentialOCL.g:4789:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            {
            // InternalEssentialOCL.g:4789:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            // InternalEssentialOCL.g:4790:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1());
            }
            // InternalEssentialOCL.g:4791:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( (LA47_0==65) ) {
                alt47=1;
            }
            switch (alt47) {
                case 1 :
                    // InternalEssentialOCL.g:4791:2: rule__CollectionLiteralPartCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__1__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0"
    // InternalEssentialOCL.g:4805:1: rule__CollectionLiteralPartCS__Group_0_1__0 : rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4809:1: ( rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 )
            // InternalEssentialOCL.g:4810:2: rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__CollectionLiteralPartCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0__Impl"
    // InternalEssentialOCL.g:4817:1: rule__CollectionLiteralPartCS__Group_0_1__0__Impl : ( '..' ) ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4821:1: ( ( '..' ) )
            // InternalEssentialOCL.g:4822:1: ( '..' )
            {
            // InternalEssentialOCL.g:4822:1: ( '..' )
            // InternalEssentialOCL.g:4823:1: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0());
            }
            match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1"
    // InternalEssentialOCL.g:4836:1: rule__CollectionLiteralPartCS__Group_0_1__1 : rule__CollectionLiteralPartCS__Group_0_1__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4840:1: ( rule__CollectionLiteralPartCS__Group_0_1__1__Impl )
            // InternalEssentialOCL.g:4841:2: rule__CollectionLiteralPartCS__Group_0_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1__Impl"
    // InternalEssentialOCL.g:4847:1: rule__CollectionLiteralPartCS__Group_0_1__1__Impl : ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4851:1: ( ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) )
            // InternalEssentialOCL.g:4852:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            {
            // InternalEssentialOCL.g:4852:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            // InternalEssentialOCL.g:4853:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1());
            }
            // InternalEssentialOCL.g:4854:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            // InternalEssentialOCL.g:4854:2: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__0"
    // InternalEssentialOCL.g:4868:1: rule__CollectionPatternCS__Group__0 : rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 ;
    public final void rule__CollectionPatternCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4872:1: ( rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 )
            // InternalEssentialOCL.g:4873:2: rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__CollectionPatternCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__0"


    // $ANTLR start "rule__CollectionPatternCS__Group__0__Impl"
    // InternalEssentialOCL.g:4880:1: rule__CollectionPatternCS__Group__0__Impl : ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionPatternCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4884:1: ( ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) )
            // InternalEssentialOCL.g:4885:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEssentialOCL.g:4885:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            // InternalEssentialOCL.g:4886:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalEssentialOCL.g:4887:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            // InternalEssentialOCL.g:4887:2: rule__CollectionPatternCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__1"
    // InternalEssentialOCL.g:4897:1: rule__CollectionPatternCS__Group__1 : rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 ;
    public final void rule__CollectionPatternCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4901:1: ( rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 )
            // InternalEssentialOCL.g:4902:2: rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__CollectionPatternCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__1"


    // $ANTLR start "rule__CollectionPatternCS__Group__1__Impl"
    // InternalEssentialOCL.g:4909:1: rule__CollectionPatternCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionPatternCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4913:1: ( ( '{' ) )
            // InternalEssentialOCL.g:4914:1: ( '{' )
            {
            // InternalEssentialOCL.g:4914:1: ( '{' )
            // InternalEssentialOCL.g:4915:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__2"
    // InternalEssentialOCL.g:4928:1: rule__CollectionPatternCS__Group__2 : rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 ;
    public final void rule__CollectionPatternCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4932:1: ( rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 )
            // InternalEssentialOCL.g:4933:2: rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__CollectionPatternCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__2"


    // $ANTLR start "rule__CollectionPatternCS__Group__2__Impl"
    // InternalEssentialOCL.g:4940:1: rule__CollectionPatternCS__Group__2__Impl : ( ( rule__CollectionPatternCS__Group_2__0 )? ) ;
    public final void rule__CollectionPatternCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4944:1: ( ( ( rule__CollectionPatternCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:4945:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:4945:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            // InternalEssentialOCL.g:4946:1: ( rule__CollectionPatternCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:4947:1: ( rule__CollectionPatternCS__Group_2__0 )?
            int alt48=2;
            int LA48_0 = input.LA(1);

            if ( ((LA48_0>=RULE_SIMPLE_ID && LA48_0<=RULE_ESCAPED_ID)||LA48_0==62) ) {
                alt48=1;
            }
            switch (alt48) {
                case 1 :
                    // InternalEssentialOCL.g:4947:2: rule__CollectionPatternCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionPatternCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__3"
    // InternalEssentialOCL.g:4957:1: rule__CollectionPatternCS__Group__3 : rule__CollectionPatternCS__Group__3__Impl ;
    public final void rule__CollectionPatternCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4961:1: ( rule__CollectionPatternCS__Group__3__Impl )
            // InternalEssentialOCL.g:4962:2: rule__CollectionPatternCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__3"


    // $ANTLR start "rule__CollectionPatternCS__Group__3__Impl"
    // InternalEssentialOCL.g:4968:1: rule__CollectionPatternCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionPatternCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4972:1: ( ( '}' ) )
            // InternalEssentialOCL.g:4973:1: ( '}' )
            {
            // InternalEssentialOCL.g:4973:1: ( '}' )
            // InternalEssentialOCL.g:4974:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__3__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__0"
    // InternalEssentialOCL.g:4995:1: rule__CollectionPatternCS__Group_2__0 : rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 ;
    public final void rule__CollectionPatternCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:4999:1: ( rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 )
            // InternalEssentialOCL.g:5000:2: rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_19);
            rule__CollectionPatternCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:5007:1: rule__CollectionPatternCS__Group_2__0__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CollectionPatternCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5011:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEssentialOCL.g:5012:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEssentialOCL.g:5012:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            // InternalEssentialOCL.g:5013:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalEssentialOCL.g:5014:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            // InternalEssentialOCL.g:5014:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__1"
    // InternalEssentialOCL.g:5024:1: rule__CollectionPatternCS__Group_2__1 : rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 ;
    public final void rule__CollectionPatternCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5028:1: ( rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 )
            // InternalEssentialOCL.g:5029:2: rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_19);
            rule__CollectionPatternCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:5036:1: rule__CollectionPatternCS__Group_2__1__Impl : ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) ;
    public final void rule__CollectionPatternCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5040:1: ( ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) )
            // InternalEssentialOCL.g:5041:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            {
            // InternalEssentialOCL.g:5041:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            // InternalEssentialOCL.g:5042:1: ( rule__CollectionPatternCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1());
            }
            // InternalEssentialOCL.g:5043:1: ( rule__CollectionPatternCS__Group_2_1__0 )*
            loop49:
            do {
                int alt49=2;
                int LA49_0 = input.LA(1);

                if ( (LA49_0==61) ) {
                    alt49=1;
                }


                switch (alt49) {
            	case 1 :
            	    // InternalEssentialOCL.g:5043:2: rule__CollectionPatternCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__CollectionPatternCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__2"
    // InternalEssentialOCL.g:5053:1: rule__CollectionPatternCS__Group_2__2 : rule__CollectionPatternCS__Group_2__2__Impl ;
    public final void rule__CollectionPatternCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5057:1: ( rule__CollectionPatternCS__Group_2__2__Impl )
            // InternalEssentialOCL.g:5058:2: rule__CollectionPatternCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__2"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__2__Impl"
    // InternalEssentialOCL.g:5064:1: rule__CollectionPatternCS__Group_2__2__Impl : ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) ;
    public final void rule__CollectionPatternCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5068:1: ( ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) )
            // InternalEssentialOCL.g:5069:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            {
            // InternalEssentialOCL.g:5069:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            // InternalEssentialOCL.g:5070:1: ( rule__CollectionPatternCS__Group_2_2__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2());
            }
            // InternalEssentialOCL.g:5071:1: ( rule__CollectionPatternCS__Group_2_2__0 )
            // InternalEssentialOCL.g:5071:2: rule__CollectionPatternCS__Group_2_2__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__2__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0"
    // InternalEssentialOCL.g:5087:1: rule__CollectionPatternCS__Group_2_1__0 : rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 ;
    public final void rule__CollectionPatternCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5091:1: ( rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 )
            // InternalEssentialOCL.g:5092:2: rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_16);
            rule__CollectionPatternCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0__Impl"
    // InternalEssentialOCL.g:5099:1: rule__CollectionPatternCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionPatternCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5103:1: ( ( ',' ) )
            // InternalEssentialOCL.g:5104:1: ( ',' )
            {
            // InternalEssentialOCL.g:5104:1: ( ',' )
            // InternalEssentialOCL.g:5105:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1"
    // InternalEssentialOCL.g:5118:1: rule__CollectionPatternCS__Group_2_1__1 : rule__CollectionPatternCS__Group_2_1__1__Impl ;
    public final void rule__CollectionPatternCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5122:1: ( rule__CollectionPatternCS__Group_2_1__1__Impl )
            // InternalEssentialOCL.g:5123:2: rule__CollectionPatternCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1__Impl"
    // InternalEssentialOCL.g:5129:1: rule__CollectionPatternCS__Group_2_1__1__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CollectionPatternCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5133:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEssentialOCL.g:5134:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEssentialOCL.g:5134:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEssentialOCL.g:5135:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalEssentialOCL.g:5136:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            // InternalEssentialOCL.g:5136:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0"
    // InternalEssentialOCL.g:5150:1: rule__CollectionPatternCS__Group_2_2__0 : rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 ;
    public final void rule__CollectionPatternCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5154:1: ( rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 )
            // InternalEssentialOCL.g:5155:2: rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__CollectionPatternCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0__Impl"
    // InternalEssentialOCL.g:5162:1: rule__CollectionPatternCS__Group_2_2__0__Impl : ( '++' ) ;
    public final void rule__CollectionPatternCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5166:1: ( ( '++' ) )
            // InternalEssentialOCL.g:5167:1: ( '++' )
            {
            // InternalEssentialOCL.g:5167:1: ( '++' )
            // InternalEssentialOCL.g:5168:1: '++'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0());
            }
            match(input,66,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1"
    // InternalEssentialOCL.g:5181:1: rule__CollectionPatternCS__Group_2_2__1 : rule__CollectionPatternCS__Group_2_2__1__Impl ;
    public final void rule__CollectionPatternCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5185:1: ( rule__CollectionPatternCS__Group_2_2__1__Impl )
            // InternalEssentialOCL.g:5186:2: rule__CollectionPatternCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1__Impl"
    // InternalEssentialOCL.g:5192:1: rule__CollectionPatternCS__Group_2_2__1__Impl : ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) ;
    public final void rule__CollectionPatternCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5196:1: ( ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) )
            // InternalEssentialOCL.g:5197:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            {
            // InternalEssentialOCL.g:5197:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            // InternalEssentialOCL.g:5198:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1());
            }
            // InternalEssentialOCL.g:5199:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            // InternalEssentialOCL.g:5199:2: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__0"
    // InternalEssentialOCL.g:5213:1: rule__ShadowPartCS__Group_0__0 : rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 ;
    public final void rule__ShadowPartCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5217:1: ( rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 )
            // InternalEssentialOCL.g:5218:2: rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_20);
            rule__ShadowPartCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__0"


    // $ANTLR start "rule__ShadowPartCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:5225:1: rule__ShadowPartCS__Group_0__0__Impl : ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) ;
    public final void rule__ShadowPartCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5229:1: ( ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) )
            // InternalEssentialOCL.g:5230:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) )
            {
            // InternalEssentialOCL.g:5230:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) )
            // InternalEssentialOCL.g:5231:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0());
            }
            // InternalEssentialOCL.g:5232:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 )
            // InternalEssentialOCL.g:5232:2: rule__ShadowPartCS__ReferredPropertyAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__ReferredPropertyAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__0__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__1"
    // InternalEssentialOCL.g:5242:1: rule__ShadowPartCS__Group_0__1 : rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 ;
    public final void rule__ShadowPartCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5246:1: ( rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 )
            // InternalEssentialOCL.g:5247:2: rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_16);
            rule__ShadowPartCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__1"


    // $ANTLR start "rule__ShadowPartCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:5254:1: rule__ShadowPartCS__Group_0__1__Impl : ( '=' ) ;
    public final void rule__ShadowPartCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5258:1: ( ( '=' ) )
            // InternalEssentialOCL.g:5259:1: ( '=' )
            {
            // InternalEssentialOCL.g:5259:1: ( '=' )
            // InternalEssentialOCL.g:5260:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__1__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__2"
    // InternalEssentialOCL.g:5273:1: rule__ShadowPartCS__Group_0__2 : rule__ShadowPartCS__Group_0__2__Impl ;
    public final void rule__ShadowPartCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5277:1: ( rule__ShadowPartCS__Group_0__2__Impl )
            // InternalEssentialOCL.g:5278:2: rule__ShadowPartCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__2"


    // $ANTLR start "rule__ShadowPartCS__Group_0__2__Impl"
    // InternalEssentialOCL.g:5284:1: rule__ShadowPartCS__Group_0__2__Impl : ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) ;
    public final void rule__ShadowPartCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5288:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) )
            // InternalEssentialOCL.g:5289:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) )
            {
            // InternalEssentialOCL.g:5289:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) )
            // InternalEssentialOCL.g:5290:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2());
            }
            // InternalEssentialOCL.g:5291:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 )
            // InternalEssentialOCL.g:5291:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__2__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__0"
    // InternalEssentialOCL.g:5307:1: rule__PatternExpCS__Group__0 : rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 ;
    public final void rule__PatternExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5311:1: ( rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 )
            // InternalEssentialOCL.g:5312:2: rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_16);
            rule__PatternExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__0"


    // $ANTLR start "rule__PatternExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:5319:1: rule__PatternExpCS__Group__0__Impl : ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) ;
    public final void rule__PatternExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5323:1: ( ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) )
            // InternalEssentialOCL.g:5324:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            {
            // InternalEssentialOCL.g:5324:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            // InternalEssentialOCL.g:5325:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0());
            }
            // InternalEssentialOCL.g:5326:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            int alt50=2;
            int LA50_0 = input.LA(1);

            if ( ((LA50_0>=RULE_SIMPLE_ID && LA50_0<=RULE_ESCAPED_ID)) ) {
                alt50=1;
            }
            switch (alt50) {
                case 1 :
                    // InternalEssentialOCL.g:5326:2: rule__PatternExpCS__PatternVariableNameAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PatternExpCS__PatternVariableNameAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__0__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__1"
    // InternalEssentialOCL.g:5336:1: rule__PatternExpCS__Group__1 : rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 ;
    public final void rule__PatternExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5340:1: ( rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 )
            // InternalEssentialOCL.g:5341:2: rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__PatternExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__1"


    // $ANTLR start "rule__PatternExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:5348:1: rule__PatternExpCS__Group__1__Impl : ( ':' ) ;
    public final void rule__PatternExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5352:1: ( ( ':' ) )
            // InternalEssentialOCL.g:5353:1: ( ':' )
            {
            // InternalEssentialOCL.g:5353:1: ( ':' )
            // InternalEssentialOCL.g:5354:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getColonKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getColonKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__1__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__2"
    // InternalEssentialOCL.g:5367:1: rule__PatternExpCS__Group__2 : rule__PatternExpCS__Group__2__Impl ;
    public final void rule__PatternExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5371:1: ( rule__PatternExpCS__Group__2__Impl )
            // InternalEssentialOCL.g:5372:2: rule__PatternExpCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__2"


    // $ANTLR start "rule__PatternExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:5378:1: rule__PatternExpCS__Group__2__Impl : ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) ;
    public final void rule__PatternExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5382:1: ( ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) )
            // InternalEssentialOCL.g:5383:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            {
            // InternalEssentialOCL.g:5383:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            // InternalEssentialOCL.g:5384:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2());
            }
            // InternalEssentialOCL.g:5385:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            // InternalEssentialOCL.g:5385:2: rule__PatternExpCS__OwnedPatternTypeAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__OwnedPatternTypeAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__2__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:5401:1: rule__LambdaLiteralExpCS__Group__0 : rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 ;
    public final void rule__LambdaLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5405:1: ( rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:5406:2: rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__LambdaLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__0"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:5413:1: rule__LambdaLiteralExpCS__Group__0__Impl : ( 'Lambda' ) ;
    public final void rule__LambdaLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5417:1: ( ( 'Lambda' ) )
            // InternalEssentialOCL.g:5418:1: ( 'Lambda' )
            {
            // InternalEssentialOCL.g:5418:1: ( 'Lambda' )
            // InternalEssentialOCL.g:5419:1: 'Lambda'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0());
            }
            match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:5432:1: rule__LambdaLiteralExpCS__Group__1 : rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 ;
    public final void rule__LambdaLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5436:1: ( rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 )
            // InternalEssentialOCL.g:5437:2: rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__LambdaLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__1"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:5444:1: rule__LambdaLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__LambdaLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5448:1: ( ( '{' ) )
            // InternalEssentialOCL.g:5449:1: ( '{' )
            {
            // InternalEssentialOCL.g:5449:1: ( '{' )
            // InternalEssentialOCL.g:5450:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__2"
    // InternalEssentialOCL.g:5463:1: rule__LambdaLiteralExpCS__Group__2 : rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 ;
    public final void rule__LambdaLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5467:1: ( rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 )
            // InternalEssentialOCL.g:5468:2: rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_21);
            rule__LambdaLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__2"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:5475:1: rule__LambdaLiteralExpCS__Group__2__Impl : ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) ;
    public final void rule__LambdaLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5479:1: ( ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) )
            // InternalEssentialOCL.g:5480:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            {
            // InternalEssentialOCL.g:5480:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            // InternalEssentialOCL.g:5481:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2());
            }
            // InternalEssentialOCL.g:5482:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            // InternalEssentialOCL.g:5482:2: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__3"
    // InternalEssentialOCL.g:5492:1: rule__LambdaLiteralExpCS__Group__3 : rule__LambdaLiteralExpCS__Group__3__Impl ;
    public final void rule__LambdaLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5496:1: ( rule__LambdaLiteralExpCS__Group__3__Impl )
            // InternalEssentialOCL.g:5497:2: rule__LambdaLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__3"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:5503:1: rule__LambdaLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__LambdaLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5507:1: ( ( '}' ) )
            // InternalEssentialOCL.g:5508:1: ( '}' )
            {
            // InternalEssentialOCL.g:5508:1: ( '}' )
            // InternalEssentialOCL.g:5509:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:5530:1: rule__MapLiteralExpCS__Group__0 : rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 ;
    public final void rule__MapLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5534:1: ( rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:5535:2: rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__MapLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:5542:1: rule__MapLiteralExpCS__Group__0__Impl : ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__MapLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5546:1: ( ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalEssentialOCL.g:5547:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEssentialOCL.g:5547:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalEssentialOCL.g:5548:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalEssentialOCL.g:5549:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalEssentialOCL.g:5549:2: rule__MapLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:5559:1: rule__MapLiteralExpCS__Group__1 : rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 ;
    public final void rule__MapLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5563:1: ( rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 )
            // InternalEssentialOCL.g:5564:2: rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_22);
            rule__MapLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:5571:1: rule__MapLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__MapLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5575:1: ( ( '{' ) )
            // InternalEssentialOCL.g:5576:1: ( '{' )
            {
            // InternalEssentialOCL.g:5576:1: ( '{' )
            // InternalEssentialOCL.g:5577:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__2"
    // InternalEssentialOCL.g:5590:1: rule__MapLiteralExpCS__Group__2 : rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 ;
    public final void rule__MapLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5594:1: ( rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 )
            // InternalEssentialOCL.g:5595:2: rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_22);
            rule__MapLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__2"


    // $ANTLR start "rule__MapLiteralExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:5602:1: rule__MapLiteralExpCS__Group__2__Impl : ( ( rule__MapLiteralExpCS__Group_2__0 )? ) ;
    public final void rule__MapLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5606:1: ( ( ( rule__MapLiteralExpCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:5607:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:5607:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            // InternalEssentialOCL.g:5608:1: ( rule__MapLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:5609:1: ( rule__MapLiteralExpCS__Group_2__0 )?
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( ((LA51_0>=RULE_INT && LA51_0<=RULE_ESCAPED_ID)||(LA51_0>=16 && LA51_0<=19)||(LA51_0>=40 && LA51_0<=54)||LA51_0==59||(LA51_0>=67 && LA51_0<=69)||LA51_0==74||(LA51_0>=79 && LA51_0<=80)||(LA51_0>=84 && LA51_0<=85)) ) {
                alt51=1;
            }
            switch (alt51) {
                case 1 :
                    // InternalEssentialOCL.g:5609:2: rule__MapLiteralExpCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MapLiteralExpCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__3"
    // InternalEssentialOCL.g:5619:1: rule__MapLiteralExpCS__Group__3 : rule__MapLiteralExpCS__Group__3__Impl ;
    public final void rule__MapLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5623:1: ( rule__MapLiteralExpCS__Group__3__Impl )
            // InternalEssentialOCL.g:5624:2: rule__MapLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__3"


    // $ANTLR start "rule__MapLiteralExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:5630:1: rule__MapLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__MapLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5634:1: ( ( '}' ) )
            // InternalEssentialOCL.g:5635:1: ( '}' )
            {
            // InternalEssentialOCL.g:5635:1: ( '}' )
            // InternalEssentialOCL.g:5636:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__0"
    // InternalEssentialOCL.g:5657:1: rule__MapLiteralExpCS__Group_2__0 : rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 ;
    public final void rule__MapLiteralExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5661:1: ( rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 )
            // InternalEssentialOCL.g:5662:2: rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__MapLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:5669:1: rule__MapLiteralExpCS__Group_2__0__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__MapLiteralExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5673:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEssentialOCL.g:5674:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEssentialOCL.g:5674:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalEssentialOCL.g:5675:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalEssentialOCL.g:5676:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalEssentialOCL.g:5676:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__1"
    // InternalEssentialOCL.g:5686:1: rule__MapLiteralExpCS__Group_2__1 : rule__MapLiteralExpCS__Group_2__1__Impl ;
    public final void rule__MapLiteralExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5690:1: ( rule__MapLiteralExpCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:5691:2: rule__MapLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:5697:1: rule__MapLiteralExpCS__Group_2__1__Impl : ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) ;
    public final void rule__MapLiteralExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5701:1: ( ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) )
            // InternalEssentialOCL.g:5702:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalEssentialOCL.g:5702:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            // InternalEssentialOCL.g:5703:1: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1());
            }
            // InternalEssentialOCL.g:5704:1: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            loop52:
            do {
                int alt52=2;
                int LA52_0 = input.LA(1);

                if ( (LA52_0==61) ) {
                    alt52=1;
                }


                switch (alt52) {
            	case 1 :
            	    // InternalEssentialOCL.g:5704:2: rule__MapLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__MapLiteralExpCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0"
    // InternalEssentialOCL.g:5718:1: rule__MapLiteralExpCS__Group_2_1__0 : rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 ;
    public final void rule__MapLiteralExpCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5722:1: ( rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 )
            // InternalEssentialOCL.g:5723:2: rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__MapLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0__Impl"
    // InternalEssentialOCL.g:5730:1: rule__MapLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__MapLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5734:1: ( ( ',' ) )
            // InternalEssentialOCL.g:5735:1: ( ',' )
            {
            // InternalEssentialOCL.g:5735:1: ( ',' )
            // InternalEssentialOCL.g:5736:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1"
    // InternalEssentialOCL.g:5749:1: rule__MapLiteralExpCS__Group_2_1__1 : rule__MapLiteralExpCS__Group_2_1__1__Impl ;
    public final void rule__MapLiteralExpCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5753:1: ( rule__MapLiteralExpCS__Group_2_1__1__Impl )
            // InternalEssentialOCL.g:5754:2: rule__MapLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1__Impl"
    // InternalEssentialOCL.g:5760:1: rule__MapLiteralExpCS__Group_2_1__1__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__MapLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5764:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEssentialOCL.g:5765:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEssentialOCL.g:5765:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEssentialOCL.g:5766:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalEssentialOCL.g:5767:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalEssentialOCL.g:5767:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__0"
    // InternalEssentialOCL.g:5781:1: rule__MapLiteralPartCS__Group__0 : rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 ;
    public final void rule__MapLiteralPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5785:1: ( rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 )
            // InternalEssentialOCL.g:5786:2: rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__MapLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__0"


    // $ANTLR start "rule__MapLiteralPartCS__Group__0__Impl"
    // InternalEssentialOCL.g:5793:1: rule__MapLiteralPartCS__Group__0__Impl : ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) ;
    public final void rule__MapLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5797:1: ( ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) )
            // InternalEssentialOCL.g:5798:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            {
            // InternalEssentialOCL.g:5798:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            // InternalEssentialOCL.g:5799:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0());
            }
            // InternalEssentialOCL.g:5800:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            // InternalEssentialOCL.g:5800:2: rule__MapLiteralPartCS__OwnedKeyAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__OwnedKeyAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__0__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__1"
    // InternalEssentialOCL.g:5810:1: rule__MapLiteralPartCS__Group__1 : rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 ;
    public final void rule__MapLiteralPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5814:1: ( rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 )
            // InternalEssentialOCL.g:5815:2: rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__MapLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__1"


    // $ANTLR start "rule__MapLiteralPartCS__Group__1__Impl"
    // InternalEssentialOCL.g:5822:1: rule__MapLiteralPartCS__Group__1__Impl : ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) ;
    public final void rule__MapLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5826:1: ( ( ( rule__MapLiteralPartCS__Alternatives_1 ) ) )
            // InternalEssentialOCL.g:5827:1: ( ( rule__MapLiteralPartCS__Alternatives_1 ) )
            {
            // InternalEssentialOCL.g:5827:1: ( ( rule__MapLiteralPartCS__Alternatives_1 ) )
            // InternalEssentialOCL.g:5828:1: ( rule__MapLiteralPartCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getAlternatives_1());
            }
            // InternalEssentialOCL.g:5829:1: ( rule__MapLiteralPartCS__Alternatives_1 )
            // InternalEssentialOCL.g:5829:2: rule__MapLiteralPartCS__Alternatives_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Alternatives_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getAlternatives_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__1__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__2"
    // InternalEssentialOCL.g:5839:1: rule__MapLiteralPartCS__Group__2 : rule__MapLiteralPartCS__Group__2__Impl ;
    public final void rule__MapLiteralPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5843:1: ( rule__MapLiteralPartCS__Group__2__Impl )
            // InternalEssentialOCL.g:5844:2: rule__MapLiteralPartCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__2"


    // $ANTLR start "rule__MapLiteralPartCS__Group__2__Impl"
    // InternalEssentialOCL.g:5850:1: rule__MapLiteralPartCS__Group__2__Impl : ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) ;
    public final void rule__MapLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5854:1: ( ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) )
            // InternalEssentialOCL.g:5855:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            {
            // InternalEssentialOCL.g:5855:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            // InternalEssentialOCL.g:5856:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2());
            }
            // InternalEssentialOCL.g:5857:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            // InternalEssentialOCL.g:5857:2: rule__MapLiteralPartCS__OwnedValueAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__OwnedValueAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:5873:1: rule__TupleLiteralExpCS__Group__0 : rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 ;
    public final void rule__TupleLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5877:1: ( rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:5878:2: rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__TupleLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__0"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:5885:1: rule__TupleLiteralExpCS__Group__0__Impl : ( 'Tuple' ) ;
    public final void rule__TupleLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5889:1: ( ( 'Tuple' ) )
            // InternalEssentialOCL.g:5890:1: ( 'Tuple' )
            {
            // InternalEssentialOCL.g:5890:1: ( 'Tuple' )
            // InternalEssentialOCL.g:5891:1: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0());
            }
            match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:5904:1: rule__TupleLiteralExpCS__Group__1 : rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 ;
    public final void rule__TupleLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5908:1: ( rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 )
            // InternalEssentialOCL.g:5909:2: rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TupleLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__1"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:5916:1: rule__TupleLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__TupleLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5920:1: ( ( '{' ) )
            // InternalEssentialOCL.g:5921:1: ( '{' )
            {
            // InternalEssentialOCL.g:5921:1: ( '{' )
            // InternalEssentialOCL.g:5922:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__2"
    // InternalEssentialOCL.g:5935:1: rule__TupleLiteralExpCS__Group__2 : rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 ;
    public final void rule__TupleLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5939:1: ( rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 )
            // InternalEssentialOCL.g:5940:2: rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__TupleLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__2"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:5947:1: rule__TupleLiteralExpCS__Group__2__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) ;
    public final void rule__TupleLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5951:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) )
            // InternalEssentialOCL.g:5952:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            {
            // InternalEssentialOCL.g:5952:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            // InternalEssentialOCL.g:5953:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2());
            }
            // InternalEssentialOCL.g:5954:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            // InternalEssentialOCL.g:5954:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__OwnedPartsAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__3"
    // InternalEssentialOCL.g:5964:1: rule__TupleLiteralExpCS__Group__3 : rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 ;
    public final void rule__TupleLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5968:1: ( rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 )
            // InternalEssentialOCL.g:5969:2: rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__TupleLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__3"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:5976:1: rule__TupleLiteralExpCS__Group__3__Impl : ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) ;
    public final void rule__TupleLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5980:1: ( ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) )
            // InternalEssentialOCL.g:5981:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            {
            // InternalEssentialOCL.g:5981:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            // InternalEssentialOCL.g:5982:1: ( rule__TupleLiteralExpCS__Group_3__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3());
            }
            // InternalEssentialOCL.g:5983:1: ( rule__TupleLiteralExpCS__Group_3__0 )*
            loop53:
            do {
                int alt53=2;
                int LA53_0 = input.LA(1);

                if ( (LA53_0==61) ) {
                    alt53=1;
                }


                switch (alt53) {
            	case 1 :
            	    // InternalEssentialOCL.g:5983:2: rule__TupleLiteralExpCS__Group_3__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__TupleLiteralExpCS__Group_3__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__4"
    // InternalEssentialOCL.g:5993:1: rule__TupleLiteralExpCS__Group__4 : rule__TupleLiteralExpCS__Group__4__Impl ;
    public final void rule__TupleLiteralExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:5997:1: ( rule__TupleLiteralExpCS__Group__4__Impl )
            // InternalEssentialOCL.g:5998:2: rule__TupleLiteralExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__4"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__4__Impl"
    // InternalEssentialOCL.g:6004:1: rule__TupleLiteralExpCS__Group__4__Impl : ( '}' ) ;
    public final void rule__TupleLiteralExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6008:1: ( ( '}' ) )
            // InternalEssentialOCL.g:6009:1: ( '}' )
            {
            // InternalEssentialOCL.g:6009:1: ( '}' )
            // InternalEssentialOCL.g:6010:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__4__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0"
    // InternalEssentialOCL.g:6033:1: rule__TupleLiteralExpCS__Group_3__0 : rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 ;
    public final void rule__TupleLiteralExpCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6037:1: ( rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 )
            // InternalEssentialOCL.g:6038:2: rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TupleLiteralExpCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0__Impl"
    // InternalEssentialOCL.g:6045:1: rule__TupleLiteralExpCS__Group_3__0__Impl : ( ',' ) ;
    public final void rule__TupleLiteralExpCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6049:1: ( ( ',' ) )
            // InternalEssentialOCL.g:6050:1: ( ',' )
            {
            // InternalEssentialOCL.g:6050:1: ( ',' )
            // InternalEssentialOCL.g:6051:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1"
    // InternalEssentialOCL.g:6064:1: rule__TupleLiteralExpCS__Group_3__1 : rule__TupleLiteralExpCS__Group_3__1__Impl ;
    public final void rule__TupleLiteralExpCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6068:1: ( rule__TupleLiteralExpCS__Group_3__1__Impl )
            // InternalEssentialOCL.g:6069:2: rule__TupleLiteralExpCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1__Impl"
    // InternalEssentialOCL.g:6075:1: rule__TupleLiteralExpCS__Group_3__1__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) ;
    public final void rule__TupleLiteralExpCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6079:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) )
            // InternalEssentialOCL.g:6080:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            {
            // InternalEssentialOCL.g:6080:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            // InternalEssentialOCL.g:6081:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1());
            }
            // InternalEssentialOCL.g:6082:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            // InternalEssentialOCL.g:6082:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__0"
    // InternalEssentialOCL.g:6096:1: rule__TupleLiteralPartCS__Group__0 : rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 ;
    public final void rule__TupleLiteralPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6100:1: ( rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 )
            // InternalEssentialOCL.g:6101:2: rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_25);
            rule__TupleLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__0"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__0__Impl"
    // InternalEssentialOCL.g:6108:1: rule__TupleLiteralPartCS__Group__0__Impl : ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6112:1: ( ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:6113:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:6113:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:6114:1: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:6115:1: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            // InternalEssentialOCL.g:6115:2: rule__TupleLiteralPartCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__0__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__1"
    // InternalEssentialOCL.g:6125:1: rule__TupleLiteralPartCS__Group__1 : rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 ;
    public final void rule__TupleLiteralPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6129:1: ( rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 )
            // InternalEssentialOCL.g:6130:2: rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_25);
            rule__TupleLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__1"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__1__Impl"
    // InternalEssentialOCL.g:6137:1: rule__TupleLiteralPartCS__Group__1__Impl : ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) ;
    public final void rule__TupleLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6141:1: ( ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:6142:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:6142:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            // InternalEssentialOCL.g:6143:1: ( rule__TupleLiteralPartCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:6144:1: ( rule__TupleLiteralPartCS__Group_1__0 )?
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( (LA54_0==62) ) {
                alt54=1;
            }
            switch (alt54) {
                case 1 :
                    // InternalEssentialOCL.g:6144:2: rule__TupleLiteralPartCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleLiteralPartCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__1__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__2"
    // InternalEssentialOCL.g:6154:1: rule__TupleLiteralPartCS__Group__2 : rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 ;
    public final void rule__TupleLiteralPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6158:1: ( rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 )
            // InternalEssentialOCL.g:6159:2: rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__TupleLiteralPartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__2"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__2__Impl"
    // InternalEssentialOCL.g:6166:1: rule__TupleLiteralPartCS__Group__2__Impl : ( '=' ) ;
    public final void rule__TupleLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6170:1: ( ( '=' ) )
            // InternalEssentialOCL.g:6171:1: ( '=' )
            {
            // InternalEssentialOCL.g:6171:1: ( '=' )
            // InternalEssentialOCL.g:6172:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__3"
    // InternalEssentialOCL.g:6185:1: rule__TupleLiteralPartCS__Group__3 : rule__TupleLiteralPartCS__Group__3__Impl ;
    public final void rule__TupleLiteralPartCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6189:1: ( rule__TupleLiteralPartCS__Group__3__Impl )
            // InternalEssentialOCL.g:6190:2: rule__TupleLiteralPartCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__3"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__3__Impl"
    // InternalEssentialOCL.g:6196:1: rule__TupleLiteralPartCS__Group__3__Impl : ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6200:1: ( ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) )
            // InternalEssentialOCL.g:6201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            {
            // InternalEssentialOCL.g:6201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            // InternalEssentialOCL.g:6202:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3());
            }
            // InternalEssentialOCL.g:6203:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            // InternalEssentialOCL.g:6203:2: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__3__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0"
    // InternalEssentialOCL.g:6221:1: rule__TupleLiteralPartCS__Group_1__0 : rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 ;
    public final void rule__TupleLiteralPartCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6225:1: ( rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 )
            // InternalEssentialOCL.g:6226:2: rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__TupleLiteralPartCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:6233:1: rule__TupleLiteralPartCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__TupleLiteralPartCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6237:1: ( ( ':' ) )
            // InternalEssentialOCL.g:6238:1: ( ':' )
            {
            // InternalEssentialOCL.g:6238:1: ( ':' )
            // InternalEssentialOCL.g:6239:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1"
    // InternalEssentialOCL.g:6252:1: rule__TupleLiteralPartCS__Group_1__1 : rule__TupleLiteralPartCS__Group_1__1__Impl ;
    public final void rule__TupleLiteralPartCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6256:1: ( rule__TupleLiteralPartCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:6257:2: rule__TupleLiteralPartCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__1"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:6263:1: rule__TupleLiteralPartCS__Group_1__1__Impl : ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__TupleLiteralPartCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6267:1: ( ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:6268:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:6268:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            // InternalEssentialOCL.g:6269:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalEssentialOCL.g:6270:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            // InternalEssentialOCL.g:6270:2: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__1__Impl"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:6284:1: rule__UnlimitedNaturalLiteralExpCS__Group__0 : rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6288:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:6289:2: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_26);
            rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:6296:1: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6300:1: ( ( () ) )
            // InternalEssentialOCL.g:6301:1: ( () )
            {
            // InternalEssentialOCL.g:6301:1: ( () )
            // InternalEssentialOCL.g:6302:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0());
            }
            // InternalEssentialOCL.g:6303:1: ()
            // InternalEssentialOCL.g:6305:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:6315:1: rule__UnlimitedNaturalLiteralExpCS__Group__1 : rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6319:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:6320:2: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:6326:1: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl : ( '*' ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6330:1: ( ( '*' ) )
            // InternalEssentialOCL.g:6331:1: ( '*' )
            {
            // InternalEssentialOCL.g:6331:1: ( '*' )
            // InternalEssentialOCL.g:6332:1: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1());
            }
            match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:6349:1: rule__InvalidLiteralExpCS__Group__0 : rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 ;
    public final void rule__InvalidLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6353:1: ( rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:6354:2: rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_27);
            rule__InvalidLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__0"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:6361:1: rule__InvalidLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__InvalidLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6365:1: ( ( () ) )
            // InternalEssentialOCL.g:6366:1: ( () )
            {
            // InternalEssentialOCL.g:6366:1: ( () )
            // InternalEssentialOCL.g:6367:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0());
            }
            // InternalEssentialOCL.g:6368:1: ()
            // InternalEssentialOCL.g:6370:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:6380:1: rule__InvalidLiteralExpCS__Group__1 : rule__InvalidLiteralExpCS__Group__1__Impl ;
    public final void rule__InvalidLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6384:1: ( rule__InvalidLiteralExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:6385:2: rule__InvalidLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__1"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:6391:1: rule__InvalidLiteralExpCS__Group__1__Impl : ( 'invalid' ) ;
    public final void rule__InvalidLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6395:1: ( ( 'invalid' ) )
            // InternalEssentialOCL.g:6396:1: ( 'invalid' )
            {
            // InternalEssentialOCL.g:6396:1: ( 'invalid' )
            // InternalEssentialOCL.g:6397:1: 'invalid'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1());
            }
            match(input,68,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__NullLiteralExpCS__Group__0"
    // InternalEssentialOCL.g:6414:1: rule__NullLiteralExpCS__Group__0 : rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 ;
    public final void rule__NullLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6418:1: ( rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 )
            // InternalEssentialOCL.g:6419:2: rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_28);
            rule__NullLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__0"


    // $ANTLR start "rule__NullLiteralExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:6426:1: rule__NullLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__NullLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6430:1: ( ( () ) )
            // InternalEssentialOCL.g:6431:1: ( () )
            {
            // InternalEssentialOCL.g:6431:1: ( () )
            // InternalEssentialOCL.g:6432:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0());
            }
            // InternalEssentialOCL.g:6433:1: ()
            // InternalEssentialOCL.g:6435:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__NullLiteralExpCS__Group__1"
    // InternalEssentialOCL.g:6445:1: rule__NullLiteralExpCS__Group__1 : rule__NullLiteralExpCS__Group__1__Impl ;
    public final void rule__NullLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6449:1: ( rule__NullLiteralExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:6450:2: rule__NullLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__1"


    // $ANTLR start "rule__NullLiteralExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:6456:1: rule__NullLiteralExpCS__Group__1__Impl : ( 'null' ) ;
    public final void rule__NullLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6460:1: ( ( 'null' ) )
            // InternalEssentialOCL.g:6461:1: ( 'null' )
            {
            // InternalEssentialOCL.g:6461:1: ( 'null' )
            // InternalEssentialOCL.g:6462:1: 'null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1());
            }
            match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0"
    // InternalEssentialOCL.g:6479:1: rule__TypeLiteralWithMultiplicityCS__Group__0 : rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6483:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 )
            // InternalEssentialOCL.g:6484:2: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_29);
            rule__TypeLiteralWithMultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl"
    // InternalEssentialOCL.g:6491:1: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl : ( ruleTypeLiteralCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6495:1: ( ( ruleTypeLiteralCS ) )
            // InternalEssentialOCL.g:6496:1: ( ruleTypeLiteralCS )
            {
            // InternalEssentialOCL.g:6496:1: ( ruleTypeLiteralCS )
            // InternalEssentialOCL.g:6497:1: ruleTypeLiteralCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeLiteralCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1"
    // InternalEssentialOCL.g:6508:1: rule__TypeLiteralWithMultiplicityCS__Group__1 : rule__TypeLiteralWithMultiplicityCS__Group__1__Impl ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6512:1: ( rule__TypeLiteralWithMultiplicityCS__Group__1__Impl )
            // InternalEssentialOCL.g:6513:2: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl"
    // InternalEssentialOCL.g:6519:1: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl : ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6523:1: ( ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalEssentialOCL.g:6524:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalEssentialOCL.g:6524:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            // InternalEssentialOCL.g:6525:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1());
            }
            // InternalEssentialOCL.g:6526:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==71) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // InternalEssentialOCL.g:6526:2: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group__0"
    // InternalEssentialOCL.g:6540:1: rule__TypeNameExpCS__Group__0 : rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 ;
    public final void rule__TypeNameExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6544:1: ( rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 )
            // InternalEssentialOCL.g:6545:2: rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__TypeNameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__0"


    // $ANTLR start "rule__TypeNameExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:6552:1: rule__TypeNameExpCS__Group__0__Impl : ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypeNameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6556:1: ( ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEssentialOCL.g:6557:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:6557:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalEssentialOCL.g:6558:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalEssentialOCL.g:6559:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            // InternalEssentialOCL.g:6559:2: rule__TypeNameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group__1"
    // InternalEssentialOCL.g:6569:1: rule__TypeNameExpCS__Group__1 : rule__TypeNameExpCS__Group__1__Impl ;
    public final void rule__TypeNameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6573:1: ( rule__TypeNameExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:6574:2: rule__TypeNameExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__1"


    // $ANTLR start "rule__TypeNameExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:6580:1: rule__TypeNameExpCS__Group__1__Impl : ( ( rule__TypeNameExpCS__Group_1__0 )? ) ;
    public final void rule__TypeNameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6584:1: ( ( ( rule__TypeNameExpCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:6585:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:6585:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            // InternalEssentialOCL.g:6586:1: ( rule__TypeNameExpCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:6587:1: ( rule__TypeNameExpCS__Group_1__0 )?
            int alt56=2;
            int LA56_0 = input.LA(1);

            if ( (LA56_0==63) ) {
                alt56=1;
            }
            switch (alt56) {
                case 1 :
                    // InternalEssentialOCL.g:6587:2: rule__TypeNameExpCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeNameExpCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__0"
    // InternalEssentialOCL.g:6601:1: rule__TypeNameExpCS__Group_1__0 : rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 ;
    public final void rule__TypeNameExpCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6605:1: ( rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 )
            // InternalEssentialOCL.g:6606:2: rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__TypeNameExpCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__0"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:6613:1: rule__TypeNameExpCS__Group_1__0__Impl : ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) ;
    public final void rule__TypeNameExpCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6617:1: ( ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) )
            // InternalEssentialOCL.g:6618:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            {
            // InternalEssentialOCL.g:6618:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            // InternalEssentialOCL.g:6619:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0());
            }
            // InternalEssentialOCL.g:6620:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            // InternalEssentialOCL.g:6620:2: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__1"
    // InternalEssentialOCL.g:6630:1: rule__TypeNameExpCS__Group_1__1 : rule__TypeNameExpCS__Group_1__1__Impl ;
    public final void rule__TypeNameExpCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6634:1: ( rule__TypeNameExpCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:6635:2: rule__TypeNameExpCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__1"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:6641:1: rule__TypeNameExpCS__Group_1__1__Impl : ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) ;
    public final void rule__TypeNameExpCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6645:1: ( ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) )
            // InternalEssentialOCL.g:6646:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            {
            // InternalEssentialOCL.g:6646:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            // InternalEssentialOCL.g:6647:1: ( rule__TypeNameExpCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1());
            }
            // InternalEssentialOCL.g:6648:1: ( rule__TypeNameExpCS__Group_1_1__0 )?
            int alt57=2;
            int LA57_0 = input.LA(1);

            if ( (LA57_0==63) ) {
                alt57=1;
            }
            switch (alt57) {
                case 1 :
                    // InternalEssentialOCL.g:6648:2: rule__TypeNameExpCS__Group_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeNameExpCS__Group_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0"
    // InternalEssentialOCL.g:6662:1: rule__TypeNameExpCS__Group_1_1__0 : rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 ;
    public final void rule__TypeNameExpCS__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6666:1: ( rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 )
            // InternalEssentialOCL.g:6667:2: rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__TypeNameExpCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__0"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0__Impl"
    // InternalEssentialOCL.g:6674:1: rule__TypeNameExpCS__Group_1_1__0__Impl : ( '{' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6678:1: ( ( '{' ) )
            // InternalEssentialOCL.g:6679:1: ( '{' )
            {
            // InternalEssentialOCL.g:6679:1: ( '{' )
            // InternalEssentialOCL.g:6680:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1"
    // InternalEssentialOCL.g:6693:1: rule__TypeNameExpCS__Group_1_1__1 : rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 ;
    public final void rule__TypeNameExpCS__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6697:1: ( rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 )
            // InternalEssentialOCL.g:6698:2: rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_21);
            rule__TypeNameExpCS__Group_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__1"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1__Impl"
    // InternalEssentialOCL.g:6705:1: rule__TypeNameExpCS__Group_1_1__1__Impl : ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) ;
    public final void rule__TypeNameExpCS__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6709:1: ( ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) )
            // InternalEssentialOCL.g:6710:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            {
            // InternalEssentialOCL.g:6710:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            // InternalEssentialOCL.g:6711:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1());
            }
            // InternalEssentialOCL.g:6712:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            // InternalEssentialOCL.g:6712:2: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2"
    // InternalEssentialOCL.g:6722:1: rule__TypeNameExpCS__Group_1_1__2 : rule__TypeNameExpCS__Group_1_1__2__Impl ;
    public final void rule__TypeNameExpCS__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6726:1: ( rule__TypeNameExpCS__Group_1_1__2__Impl )
            // InternalEssentialOCL.g:6727:2: rule__TypeNameExpCS__Group_1_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2__Impl"
    // InternalEssentialOCL.g:6733:1: rule__TypeNameExpCS__Group_1_1__2__Impl : ( '}' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6737:1: ( ( '}' ) )
            // InternalEssentialOCL.g:6738:1: ( '}' )
            {
            // InternalEssentialOCL.g:6738:1: ( '}' )
            // InternalEssentialOCL.g:6739:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2__Impl"


    // $ANTLR start "rule__TypeExpCS__Group__0"
    // InternalEssentialOCL.g:6758:1: rule__TypeExpCS__Group__0 : rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 ;
    public final void rule__TypeExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6762:1: ( rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 )
            // InternalEssentialOCL.g:6763:2: rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_29);
            rule__TypeExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__0"


    // $ANTLR start "rule__TypeExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:6770:1: rule__TypeExpCS__Group__0__Impl : ( ruleTypeExpWithoutMultiplicityCS ) ;
    public final void rule__TypeExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6774:1: ( ( ruleTypeExpWithoutMultiplicityCS ) )
            // InternalEssentialOCL.g:6775:1: ( ruleTypeExpWithoutMultiplicityCS )
            {
            // InternalEssentialOCL.g:6775:1: ( ruleTypeExpWithoutMultiplicityCS )
            // InternalEssentialOCL.g:6776:1: ruleTypeExpWithoutMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpWithoutMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__0__Impl"


    // $ANTLR start "rule__TypeExpCS__Group__1"
    // InternalEssentialOCL.g:6787:1: rule__TypeExpCS__Group__1 : rule__TypeExpCS__Group__1__Impl ;
    public final void rule__TypeExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6791:1: ( rule__TypeExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:6792:2: rule__TypeExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__1"


    // $ANTLR start "rule__TypeExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:6798:1: rule__TypeExpCS__Group__1__Impl : ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6802:1: ( ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalEssentialOCL.g:6803:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalEssentialOCL.g:6803:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            // InternalEssentialOCL.g:6804:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1());
            }
            // InternalEssentialOCL.g:6805:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            int alt58=2;
            int LA58_0 = input.LA(1);

            if ( (LA58_0==71) ) {
                alt58=1;
            }
            switch (alt58) {
                case 1 :
                    // InternalEssentialOCL.g:6805:2: rule__TypeExpCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeExpCS__OwnedMultiplicityAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0__0"
    // InternalEssentialOCL.g:6819:1: rule__ExpCS__Group_0__0 : rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 ;
    public final void rule__ExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6823:1: ( rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 )
            // InternalEssentialOCL.g:6824:2: rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_30);
            rule__ExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__0"


    // $ANTLR start "rule__ExpCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:6831:1: rule__ExpCS__Group_0__0__Impl : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__ExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6835:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalEssentialOCL.g:6836:1: ( rulePrefixedPrimaryExpCS )
            {
            // InternalEssentialOCL.g:6836:1: ( rulePrefixedPrimaryExpCS )
            // InternalEssentialOCL.g:6837:1: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedPrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__ExpCS__Group_0__1"
    // InternalEssentialOCL.g:6848:1: rule__ExpCS__Group_0__1 : rule__ExpCS__Group_0__1__Impl ;
    public final void rule__ExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6852:1: ( rule__ExpCS__Group_0__1__Impl )
            // InternalEssentialOCL.g:6853:2: rule__ExpCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__1"


    // $ANTLR start "rule__ExpCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:6859:1: rule__ExpCS__Group_0__1__Impl : ( ( rule__ExpCS__Group_0_1__0 )? ) ;
    public final void rule__ExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6863:1: ( ( ( rule__ExpCS__Group_0_1__0 )? ) )
            // InternalEssentialOCL.g:6864:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            {
            // InternalEssentialOCL.g:6864:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            // InternalEssentialOCL.g:6865:1: ( rule__ExpCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getGroup_0_1());
            }
            // InternalEssentialOCL.g:6866:1: ( rule__ExpCS__Group_0_1__0 )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==16||(LA59_0>=19 && LA59_0<=39)) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // InternalEssentialOCL.g:6866:2: rule__ExpCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ExpCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getGroup_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__0"
    // InternalEssentialOCL.g:6880:1: rule__ExpCS__Group_0_1__0 : rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 ;
    public final void rule__ExpCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6884:1: ( rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 )
            // InternalEssentialOCL.g:6885:2: rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_30);
            rule__ExpCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__0"


    // $ANTLR start "rule__ExpCS__Group_0_1__0__Impl"
    // InternalEssentialOCL.g:6892:1: rule__ExpCS__Group_0_1__0__Impl : ( () ) ;
    public final void rule__ExpCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6896:1: ( ( () ) )
            // InternalEssentialOCL.g:6897:1: ( () )
            {
            // InternalEssentialOCL.g:6897:1: ( () )
            // InternalEssentialOCL.g:6898:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0());
            }
            // InternalEssentialOCL.g:6899:1: ()
            // InternalEssentialOCL.g:6901:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__1"
    // InternalEssentialOCL.g:6911:1: rule__ExpCS__Group_0_1__1 : rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 ;
    public final void rule__ExpCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6915:1: ( rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 )
            // InternalEssentialOCL.g:6916:2: rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ExpCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__1"


    // $ANTLR start "rule__ExpCS__Group_0_1__1__Impl"
    // InternalEssentialOCL.g:6923:1: rule__ExpCS__Group_0_1__1__Impl : ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) ;
    public final void rule__ExpCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6927:1: ( ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) )
            // InternalEssentialOCL.g:6928:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            {
            // InternalEssentialOCL.g:6928:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            // InternalEssentialOCL.g:6929:1: ( rule__ExpCS__NameAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1());
            }
            // InternalEssentialOCL.g:6930:1: ( rule__ExpCS__NameAssignment_0_1_1 )
            // InternalEssentialOCL.g:6930:2: rule__ExpCS__NameAssignment_0_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__NameAssignment_0_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__2"
    // InternalEssentialOCL.g:6940:1: rule__ExpCS__Group_0_1__2 : rule__ExpCS__Group_0_1__2__Impl ;
    public final void rule__ExpCS__Group_0_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6944:1: ( rule__ExpCS__Group_0_1__2__Impl )
            // InternalEssentialOCL.g:6945:2: rule__ExpCS__Group_0_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__2"


    // $ANTLR start "rule__ExpCS__Group_0_1__2__Impl"
    // InternalEssentialOCL.g:6951:1: rule__ExpCS__Group_0_1__2__Impl : ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) ;
    public final void rule__ExpCS__Group_0_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6955:1: ( ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) )
            // InternalEssentialOCL.g:6956:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            {
            // InternalEssentialOCL.g:6956:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            // InternalEssentialOCL.g:6957:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2());
            }
            // InternalEssentialOCL.g:6958:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            // InternalEssentialOCL.g:6958:2: rule__ExpCS__OwnedRightAssignment_0_1_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__OwnedRightAssignment_0_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__2__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0"
    // InternalEssentialOCL.g:6974:1: rule__PrefixedLetExpCS__Group_0__0 : rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 ;
    public final void rule__PrefixedLetExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6978:1: ( rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 )
            // InternalEssentialOCL.g:6979:2: rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__PrefixedLetExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:6986:1: rule__PrefixedLetExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedLetExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:6990:1: ( ( () ) )
            // InternalEssentialOCL.g:6991:1: ( () )
            {
            // InternalEssentialOCL.g:6991:1: ( () )
            // InternalEssentialOCL.g:6992:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0());
            }
            // InternalEssentialOCL.g:6993:1: ()
            // InternalEssentialOCL.g:6995:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1"
    // InternalEssentialOCL.g:7005:1: rule__PrefixedLetExpCS__Group_0__1 : rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 ;
    public final void rule__PrefixedLetExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7009:1: ( rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 )
            // InternalEssentialOCL.g:7010:2: rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__PrefixedLetExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:7017:1: rule__PrefixedLetExpCS__Group_0__1__Impl : ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) ;
    public final void rule__PrefixedLetExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7021:1: ( ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) )
            // InternalEssentialOCL.g:7022:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            {
            // InternalEssentialOCL.g:7022:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            // InternalEssentialOCL.g:7023:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1());
            }
            // InternalEssentialOCL.g:7024:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            // InternalEssentialOCL.g:7024:2: rule__PrefixedLetExpCS__NameAssignment_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2"
    // InternalEssentialOCL.g:7034:1: rule__PrefixedLetExpCS__Group_0__2 : rule__PrefixedLetExpCS__Group_0__2__Impl ;
    public final void rule__PrefixedLetExpCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7038:1: ( rule__PrefixedLetExpCS__Group_0__2__Impl )
            // InternalEssentialOCL.g:7039:2: rule__PrefixedLetExpCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2__Impl"
    // InternalEssentialOCL.g:7045:1: rule__PrefixedLetExpCS__Group_0__2__Impl : ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) ;
    public final void rule__PrefixedLetExpCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7049:1: ( ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalEssentialOCL.g:7050:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalEssentialOCL.g:7050:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            // InternalEssentialOCL.g:7051:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2());
            }
            // InternalEssentialOCL.g:7052:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            // InternalEssentialOCL.g:7052:2: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__OwnedRightAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0"
    // InternalEssentialOCL.g:7068:1: rule__PrefixedPrimaryExpCS__Group_0__0 : rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7072:1: ( rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 )
            // InternalEssentialOCL.g:7073:2: rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__PrefixedPrimaryExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:7080:1: rule__PrefixedPrimaryExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7084:1: ( ( () ) )
            // InternalEssentialOCL.g:7085:1: ( () )
            {
            // InternalEssentialOCL.g:7085:1: ( () )
            // InternalEssentialOCL.g:7086:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0());
            }
            // InternalEssentialOCL.g:7087:1: ()
            // InternalEssentialOCL.g:7089:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1"
    // InternalEssentialOCL.g:7099:1: rule__PrefixedPrimaryExpCS__Group_0__1 : rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7103:1: ( rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 )
            // InternalEssentialOCL.g:7104:2: rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_32);
            rule__PrefixedPrimaryExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:7111:1: rule__PrefixedPrimaryExpCS__Group_0__1__Impl : ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7115:1: ( ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) )
            // InternalEssentialOCL.g:7116:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            {
            // InternalEssentialOCL.g:7116:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            // InternalEssentialOCL.g:7117:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1());
            }
            // InternalEssentialOCL.g:7118:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            // InternalEssentialOCL.g:7118:2: rule__PrefixedPrimaryExpCS__NameAssignment_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2"
    // InternalEssentialOCL.g:7128:1: rule__PrefixedPrimaryExpCS__Group_0__2 : rule__PrefixedPrimaryExpCS__Group_0__2__Impl ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7132:1: ( rule__PrefixedPrimaryExpCS__Group_0__2__Impl )
            // InternalEssentialOCL.g:7133:2: rule__PrefixedPrimaryExpCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2__Impl"
    // InternalEssentialOCL.g:7139:1: rule__PrefixedPrimaryExpCS__Group_0__2__Impl : ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7143:1: ( ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalEssentialOCL.g:7144:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalEssentialOCL.g:7144:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            // InternalEssentialOCL.g:7145:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2());
            }
            // InternalEssentialOCL.g:7146:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            // InternalEssentialOCL.g:7146:2: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2__Impl"


    // $ANTLR start "rule__NameExpCS__Group__0"
    // InternalEssentialOCL.g:7162:1: rule__NameExpCS__Group__0 : rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 ;
    public final void rule__NameExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7166:1: ( rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 )
            // InternalEssentialOCL.g:7167:2: rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__NameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__0"


    // $ANTLR start "rule__NameExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:7174:1: rule__NameExpCS__Group__0__Impl : ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__NameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7178:1: ( ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEssentialOCL.g:7179:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:7179:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalEssentialOCL.g:7180:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalEssentialOCL.g:7181:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            // InternalEssentialOCL.g:7181:2: rule__NameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__0__Impl"


    // $ANTLR start "rule__NameExpCS__Group__1"
    // InternalEssentialOCL.g:7191:1: rule__NameExpCS__Group__1 : rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 ;
    public final void rule__NameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7195:1: ( rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 )
            // InternalEssentialOCL.g:7196:2: rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__NameExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__1"


    // $ANTLR start "rule__NameExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:7203:1: rule__NameExpCS__Group__1__Impl : ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) ;
    public final void rule__NameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7207:1: ( ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) )
            // InternalEssentialOCL.g:7208:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            {
            // InternalEssentialOCL.g:7208:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            // InternalEssentialOCL.g:7209:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1());
            }
            // InternalEssentialOCL.g:7210:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            loop60:
            do {
                int alt60=2;
                int LA60_0 = input.LA(1);

                if ( (LA60_0==71) ) {
                    alt60=1;
                }


                switch (alt60) {
            	case 1 :
            	    // InternalEssentialOCL.g:7210:2: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__1__Impl"


    // $ANTLR start "rule__NameExpCS__Group__2"
    // InternalEssentialOCL.g:7220:1: rule__NameExpCS__Group__2 : rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 ;
    public final void rule__NameExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7224:1: ( rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 )
            // InternalEssentialOCL.g:7225:2: rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__NameExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__2"


    // $ANTLR start "rule__NameExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:7232:1: rule__NameExpCS__Group__2__Impl : ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) ;
    public final void rule__NameExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7236:1: ( ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) )
            // InternalEssentialOCL.g:7237:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            {
            // InternalEssentialOCL.g:7237:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            // InternalEssentialOCL.g:7238:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2());
            }
            // InternalEssentialOCL.g:7239:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            int alt61=2;
            int LA61_0 = input.LA(1);

            if ( (LA61_0==59) ) {
                alt61=1;
            }
            switch (alt61) {
                case 1 :
                    // InternalEssentialOCL.g:7239:2: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__2__Impl"


    // $ANTLR start "rule__NameExpCS__Group__3"
    // InternalEssentialOCL.g:7249:1: rule__NameExpCS__Group__3 : rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 ;
    public final void rule__NameExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7253:1: ( rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 )
            // InternalEssentialOCL.g:7254:2: rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__NameExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__3"


    // $ANTLR start "rule__NameExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:7261:1: rule__NameExpCS__Group__3__Impl : ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) ;
    public final void rule__NameExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7265:1: ( ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) )
            // InternalEssentialOCL.g:7266:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            {
            // InternalEssentialOCL.g:7266:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            // InternalEssentialOCL.g:7267:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3());
            }
            // InternalEssentialOCL.g:7268:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( (LA62_0==63) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // InternalEssentialOCL.g:7268:2: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__3__Impl"


    // $ANTLR start "rule__NameExpCS__Group__4"
    // InternalEssentialOCL.g:7278:1: rule__NameExpCS__Group__4 : rule__NameExpCS__Group__4__Impl ;
    public final void rule__NameExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7282:1: ( rule__NameExpCS__Group__4__Impl )
            // InternalEssentialOCL.g:7283:2: rule__NameExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__4"


    // $ANTLR start "rule__NameExpCS__Group__4__Impl"
    // InternalEssentialOCL.g:7289:1: rule__NameExpCS__Group__4__Impl : ( ( rule__NameExpCS__Group_4__0 )? ) ;
    public final void rule__NameExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7293:1: ( ( ( rule__NameExpCS__Group_4__0 )? ) )
            // InternalEssentialOCL.g:7294:1: ( ( rule__NameExpCS__Group_4__0 )? )
            {
            // InternalEssentialOCL.g:7294:1: ( ( rule__NameExpCS__Group_4__0 )? )
            // InternalEssentialOCL.g:7295:1: ( rule__NameExpCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup_4());
            }
            // InternalEssentialOCL.g:7296:1: ( rule__NameExpCS__Group_4__0 )?
            int alt63=2;
            int LA63_0 = input.LA(1);

            if ( (LA63_0==86) ) {
                alt63=1;
            }
            switch (alt63) {
                case 1 :
                    // InternalEssentialOCL.g:7296:2: rule__NameExpCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__4__Impl"


    // $ANTLR start "rule__NameExpCS__Group_4__0"
    // InternalEssentialOCL.g:7316:1: rule__NameExpCS__Group_4__0 : rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 ;
    public final void rule__NameExpCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7320:1: ( rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 )
            // InternalEssentialOCL.g:7321:2: rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_35);
            rule__NameExpCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__0"


    // $ANTLR start "rule__NameExpCS__Group_4__0__Impl"
    // InternalEssentialOCL.g:7328:1: rule__NameExpCS__Group_4__0__Impl : ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) ;
    public final void rule__NameExpCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7332:1: ( ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) )
            // InternalEssentialOCL.g:7333:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            {
            // InternalEssentialOCL.g:7333:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            // InternalEssentialOCL.g:7334:1: ( rule__NameExpCS__IsPreAssignment_4_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0());
            }
            // InternalEssentialOCL.g:7335:1: ( rule__NameExpCS__IsPreAssignment_4_0 )
            // InternalEssentialOCL.g:7335:2: rule__NameExpCS__IsPreAssignment_4_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__IsPreAssignment_4_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__0__Impl"


    // $ANTLR start "rule__NameExpCS__Group_4__1"
    // InternalEssentialOCL.g:7345:1: rule__NameExpCS__Group_4__1 : rule__NameExpCS__Group_4__1__Impl ;
    public final void rule__NameExpCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7349:1: ( rule__NameExpCS__Group_4__1__Impl )
            // InternalEssentialOCL.g:7350:2: rule__NameExpCS__Group_4__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__1"


    // $ANTLR start "rule__NameExpCS__Group_4__1__Impl"
    // InternalEssentialOCL.g:7356:1: rule__NameExpCS__Group_4__1__Impl : ( 'pre' ) ;
    public final void rule__NameExpCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7360:1: ( ( 'pre' ) )
            // InternalEssentialOCL.g:7361:1: ( 'pre' )
            {
            // InternalEssentialOCL.g:7361:1: ( 'pre' )
            // InternalEssentialOCL.g:7362:1: 'pre'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1());
            }
            match(input,70,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0"
    // InternalEssentialOCL.g:7379:1: rule__CurlyBracketedClauseCS__Group__0 : rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 ;
    public final void rule__CurlyBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7383:1: ( rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 )
            // InternalEssentialOCL.g:7384:2: rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__CurlyBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0__Impl"
    // InternalEssentialOCL.g:7391:1: rule__CurlyBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__CurlyBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7395:1: ( ( () ) )
            // InternalEssentialOCL.g:7396:1: ( () )
            {
            // InternalEssentialOCL.g:7396:1: ( () )
            // InternalEssentialOCL.g:7397:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0());
            }
            // InternalEssentialOCL.g:7398:1: ()
            // InternalEssentialOCL.g:7400:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1"
    // InternalEssentialOCL.g:7410:1: rule__CurlyBracketedClauseCS__Group__1 : rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 ;
    public final void rule__CurlyBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7414:1: ( rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 )
            // InternalEssentialOCL.g:7415:2: rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_36);
            rule__CurlyBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1__Impl"
    // InternalEssentialOCL.g:7422:1: rule__CurlyBracketedClauseCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7426:1: ( ( '{' ) )
            // InternalEssentialOCL.g:7427:1: ( '{' )
            {
            // InternalEssentialOCL.g:7427:1: ( '{' )
            // InternalEssentialOCL.g:7428:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2"
    // InternalEssentialOCL.g:7441:1: rule__CurlyBracketedClauseCS__Group__2 : rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 ;
    public final void rule__CurlyBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7445:1: ( rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 )
            // InternalEssentialOCL.g:7446:2: rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_36);
            rule__CurlyBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2__Impl"
    // InternalEssentialOCL.g:7453:1: rule__CurlyBracketedClauseCS__Group__2__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) ;
    public final void rule__CurlyBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7457:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:7458:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:7458:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? )
            // InternalEssentialOCL.g:7459:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:7460:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )?
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( ((LA64_0>=RULE_SINGLE_QUOTED_STRING && LA64_0<=RULE_ESCAPED_ID)) ) {
                alt64=1;
            }
            switch (alt64) {
                case 1 :
                    // InternalEssentialOCL.g:7460:2: rule__CurlyBracketedClauseCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CurlyBracketedClauseCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3"
    // InternalEssentialOCL.g:7470:1: rule__CurlyBracketedClauseCS__Group__3 : rule__CurlyBracketedClauseCS__Group__3__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7474:1: ( rule__CurlyBracketedClauseCS__Group__3__Impl )
            // InternalEssentialOCL.g:7475:2: rule__CurlyBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3__Impl"
    // InternalEssentialOCL.g:7481:1: rule__CurlyBracketedClauseCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7485:1: ( ( '}' ) )
            // InternalEssentialOCL.g:7486:1: ( '}' )
            {
            // InternalEssentialOCL.g:7486:1: ( '}' )
            // InternalEssentialOCL.g:7487:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0"
    // InternalEssentialOCL.g:7508:1: rule__CurlyBracketedClauseCS__Group_2__0 : rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7512:1: ( rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 )
            // InternalEssentialOCL.g:7513:2: rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__CurlyBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:7520:1: rule__CurlyBracketedClauseCS__Group_2__0__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7524:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEssentialOCL.g:7525:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEssentialOCL.g:7525:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) )
            // InternalEssentialOCL.g:7526:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalEssentialOCL.g:7527:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 )
            // InternalEssentialOCL.g:7527:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1"
    // InternalEssentialOCL.g:7537:1: rule__CurlyBracketedClauseCS__Group_2__1 : rule__CurlyBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7541:1: ( rule__CurlyBracketedClauseCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:7542:2: rule__CurlyBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:7548:1: rule__CurlyBracketedClauseCS__Group_2__1__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7552:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) )
            // InternalEssentialOCL.g:7553:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* )
            {
            // InternalEssentialOCL.g:7553:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* )
            // InternalEssentialOCL.g:7554:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1());
            }
            // InternalEssentialOCL.g:7555:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )*
            loop65:
            do {
                int alt65=2;
                int LA65_0 = input.LA(1);

                if ( (LA65_0==61) ) {
                    alt65=1;
                }


                switch (alt65) {
            	case 1 :
            	    // InternalEssentialOCL.g:7555:2: rule__CurlyBracketedClauseCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__CurlyBracketedClauseCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0"
    // InternalEssentialOCL.g:7569:1: rule__CurlyBracketedClauseCS__Group_2_1__0 : rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7573:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 )
            // InternalEssentialOCL.g:7574:2: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_37);
            rule__CurlyBracketedClauseCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl"
    // InternalEssentialOCL.g:7581:1: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7585:1: ( ( ',' ) )
            // InternalEssentialOCL.g:7586:1: ( ',' )
            {
            // InternalEssentialOCL.g:7586:1: ( ',' )
            // InternalEssentialOCL.g:7587:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1"
    // InternalEssentialOCL.g:7600:1: rule__CurlyBracketedClauseCS__Group_2_1__1 : rule__CurlyBracketedClauseCS__Group_2_1__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7604:1: ( rule__CurlyBracketedClauseCS__Group_2_1__1__Impl )
            // InternalEssentialOCL.g:7605:2: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl"
    // InternalEssentialOCL.g:7611:1: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7615:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEssentialOCL.g:7616:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEssentialOCL.g:7616:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEssentialOCL.g:7617:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalEssentialOCL.g:7618:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 )
            // InternalEssentialOCL.g:7618:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__0"
    // InternalEssentialOCL.g:7632:1: rule__RoundBracketedClauseCS__Group__0 : rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 ;
    public final void rule__RoundBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7636:1: ( rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 )
            // InternalEssentialOCL.g:7637:2: rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__RoundBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__0__Impl"
    // InternalEssentialOCL.g:7644:1: rule__RoundBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__RoundBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7648:1: ( ( () ) )
            // InternalEssentialOCL.g:7649:1: ( () )
            {
            // InternalEssentialOCL.g:7649:1: ( () )
            // InternalEssentialOCL.g:7650:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0());
            }
            // InternalEssentialOCL.g:7651:1: ()
            // InternalEssentialOCL.g:7653:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__1"
    // InternalEssentialOCL.g:7663:1: rule__RoundBracketedClauseCS__Group__1 : rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 ;
    public final void rule__RoundBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7667:1: ( rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 )
            // InternalEssentialOCL.g:7668:2: rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_38);
            rule__RoundBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__1__Impl"
    // InternalEssentialOCL.g:7675:1: rule__RoundBracketedClauseCS__Group__1__Impl : ( '(' ) ;
    public final void rule__RoundBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7679:1: ( ( '(' ) )
            // InternalEssentialOCL.g:7680:1: ( '(' )
            {
            // InternalEssentialOCL.g:7680:1: ( '(' )
            // InternalEssentialOCL.g:7681:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__2"
    // InternalEssentialOCL.g:7694:1: rule__RoundBracketedClauseCS__Group__2 : rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 ;
    public final void rule__RoundBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7698:1: ( rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 )
            // InternalEssentialOCL.g:7699:2: rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_38);
            rule__RoundBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__2"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__2__Impl"
    // InternalEssentialOCL.g:7706:1: rule__RoundBracketedClauseCS__Group__2__Impl : ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) ;
    public final void rule__RoundBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7710:1: ( ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:7711:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:7711:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            // InternalEssentialOCL.g:7712:1: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:7713:1: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( ((LA66_0>=RULE_INT && LA66_0<=RULE_ESCAPED_ID)||(LA66_0>=16 && LA66_0<=19)||(LA66_0>=40 && LA66_0<=54)||LA66_0==59||LA66_0==62||(LA66_0>=67 && LA66_0<=69)||LA66_0==74||(LA66_0>=79 && LA66_0<=80)||(LA66_0>=84 && LA66_0<=85)) ) {
                alt66=1;
            }
            switch (alt66) {
                case 1 :
                    // InternalEssentialOCL.g:7713:2: rule__RoundBracketedClauseCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__RoundBracketedClauseCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__3"
    // InternalEssentialOCL.g:7723:1: rule__RoundBracketedClauseCS__Group__3 : rule__RoundBracketedClauseCS__Group__3__Impl ;
    public final void rule__RoundBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7727:1: ( rule__RoundBracketedClauseCS__Group__3__Impl )
            // InternalEssentialOCL.g:7728:2: rule__RoundBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__3"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__3__Impl"
    // InternalEssentialOCL.g:7734:1: rule__RoundBracketedClauseCS__Group__3__Impl : ( ')' ) ;
    public final void rule__RoundBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7738:1: ( ( ')' ) )
            // InternalEssentialOCL.g:7739:1: ( ')' )
            {
            // InternalEssentialOCL.g:7739:1: ( ')' )
            // InternalEssentialOCL.g:7740:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0"
    // InternalEssentialOCL.g:7761:1: rule__RoundBracketedClauseCS__Group_2__0 : rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 ;
    public final void rule__RoundBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7765:1: ( rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 )
            // InternalEssentialOCL.g:7766:2: rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_39);
            rule__RoundBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:7773:1: rule__RoundBracketedClauseCS__Group_2__0__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7777:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) )
            // InternalEssentialOCL.g:7778:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            {
            // InternalEssentialOCL.g:7778:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            // InternalEssentialOCL.g:7779:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0());
            }
            // InternalEssentialOCL.g:7780:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            // InternalEssentialOCL.g:7780:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1"
    // InternalEssentialOCL.g:7790:1: rule__RoundBracketedClauseCS__Group_2__1 : rule__RoundBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__RoundBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7794:1: ( rule__RoundBracketedClauseCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:7795:2: rule__RoundBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:7801:1: rule__RoundBracketedClauseCS__Group_2__1__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7805:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) )
            // InternalEssentialOCL.g:7806:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            {
            // InternalEssentialOCL.g:7806:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            // InternalEssentialOCL.g:7807:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1());
            }
            // InternalEssentialOCL.g:7808:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            loop67:
            do {
                int alt67=2;
                int LA67_0 = input.LA(1);

                if ( (LA67_0==61||(LA67_0>=87 && LA67_0<=88)) ) {
                    alt67=1;
                }


                switch (alt67) {
            	case 1 :
            	    // InternalEssentialOCL.g:7808:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_40);
            	    rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__0"
    // InternalEssentialOCL.g:7822:1: rule__SquareBracketedClauseCS__Group__0 : rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 ;
    public final void rule__SquareBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7826:1: ( rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 )
            // InternalEssentialOCL.g:7827:2: rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__SquareBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__0"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__0__Impl"
    // InternalEssentialOCL.g:7834:1: rule__SquareBracketedClauseCS__Group__0__Impl : ( '[' ) ;
    public final void rule__SquareBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7838:1: ( ( '[' ) )
            // InternalEssentialOCL.g:7839:1: ( '[' )
            {
            // InternalEssentialOCL.g:7839:1: ( '[' )
            // InternalEssentialOCL.g:7840:1: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__1"
    // InternalEssentialOCL.g:7853:1: rule__SquareBracketedClauseCS__Group__1 : rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 ;
    public final void rule__SquareBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7857:1: ( rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 )
            // InternalEssentialOCL.g:7858:2: rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_41);
            rule__SquareBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__1"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__1__Impl"
    // InternalEssentialOCL.g:7865:1: rule__SquareBracketedClauseCS__Group__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) ;
    public final void rule__SquareBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7869:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) )
            // InternalEssentialOCL.g:7870:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            {
            // InternalEssentialOCL.g:7870:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            // InternalEssentialOCL.g:7871:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1());
            }
            // InternalEssentialOCL.g:7872:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            // InternalEssentialOCL.g:7872:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__OwnedTermsAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__2"
    // InternalEssentialOCL.g:7882:1: rule__SquareBracketedClauseCS__Group__2 : rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 ;
    public final void rule__SquareBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7886:1: ( rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 )
            // InternalEssentialOCL.g:7887:2: rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_41);
            rule__SquareBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__2"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__2__Impl"
    // InternalEssentialOCL.g:7894:1: rule__SquareBracketedClauseCS__Group__2__Impl : ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) ;
    public final void rule__SquareBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7898:1: ( ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) )
            // InternalEssentialOCL.g:7899:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            {
            // InternalEssentialOCL.g:7899:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            // InternalEssentialOCL.g:7900:1: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:7901:1: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            loop68:
            do {
                int alt68=2;
                int LA68_0 = input.LA(1);

                if ( (LA68_0==61) ) {
                    alt68=1;
                }


                switch (alt68) {
            	case 1 :
            	    // InternalEssentialOCL.g:7901:2: rule__SquareBracketedClauseCS__Group_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__SquareBracketedClauseCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__3"
    // InternalEssentialOCL.g:7911:1: rule__SquareBracketedClauseCS__Group__3 : rule__SquareBracketedClauseCS__Group__3__Impl ;
    public final void rule__SquareBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7915:1: ( rule__SquareBracketedClauseCS__Group__3__Impl )
            // InternalEssentialOCL.g:7916:2: rule__SquareBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__3"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__3__Impl"
    // InternalEssentialOCL.g:7922:1: rule__SquareBracketedClauseCS__Group__3__Impl : ( ']' ) ;
    public final void rule__SquareBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7926:1: ( ( ']' ) )
            // InternalEssentialOCL.g:7927:1: ( ']' )
            {
            // InternalEssentialOCL.g:7927:1: ( ']' )
            // InternalEssentialOCL.g:7928:1: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0"
    // InternalEssentialOCL.g:7949:1: rule__SquareBracketedClauseCS__Group_2__0 : rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 ;
    public final void rule__SquareBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7953:1: ( rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 )
            // InternalEssentialOCL.g:7954:2: rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__SquareBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:7961:1: rule__SquareBracketedClauseCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__SquareBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7965:1: ( ( ',' ) )
            // InternalEssentialOCL.g:7966:1: ( ',' )
            {
            // InternalEssentialOCL.g:7966:1: ( ',' )
            // InternalEssentialOCL.g:7967:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1"
    // InternalEssentialOCL.g:7980:1: rule__SquareBracketedClauseCS__Group_2__1 : rule__SquareBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__SquareBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7984:1: ( rule__SquareBracketedClauseCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:7985:2: rule__SquareBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:7991:1: rule__SquareBracketedClauseCS__Group_2__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) ;
    public final void rule__SquareBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:7995:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:7996:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:7996:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            // InternalEssentialOCL.g:7997:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1());
            }
            // InternalEssentialOCL.g:7998:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            // InternalEssentialOCL.g:7998:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__0"
    // InternalEssentialOCL.g:8012:1: rule__NavigatingArgCS__Group_0__0 : rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 ;
    public final void rule__NavigatingArgCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8016:1: ( rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 )
            // InternalEssentialOCL.g:8017:2: rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingArgCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__0__Impl"
    // InternalEssentialOCL.g:8024:1: rule__NavigatingArgCS__Group_0__0__Impl : ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) ;
    public final void rule__NavigatingArgCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8028:1: ( ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) )
            // InternalEssentialOCL.g:8029:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            {
            // InternalEssentialOCL.g:8029:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            // InternalEssentialOCL.g:8030:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0());
            }
            // InternalEssentialOCL.g:8031:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            // InternalEssentialOCL.g:8031:2: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__1"
    // InternalEssentialOCL.g:8041:1: rule__NavigatingArgCS__Group_0__1 : rule__NavigatingArgCS__Group_0__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8045:1: ( rule__NavigatingArgCS__Group_0__1__Impl )
            // InternalEssentialOCL.g:8046:2: rule__NavigatingArgCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__1__Impl"
    // InternalEssentialOCL.g:8052:1: rule__NavigatingArgCS__Group_0__1__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) ;
    public final void rule__NavigatingArgCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8056:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) )
            // InternalEssentialOCL.g:8057:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            {
            // InternalEssentialOCL.g:8057:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            // InternalEssentialOCL.g:8058:1: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1());
            }
            // InternalEssentialOCL.g:8059:1: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            int alt69=2;
            int LA69_0 = input.LA(1);

            if ( ((LA69_0>=55 && LA69_0<=56)||LA69_0==62||LA69_0==73) ) {
                alt69=1;
            }
            switch (alt69) {
                case 1 :
                    // InternalEssentialOCL.g:8059:2: rule__NavigatingArgCS__Alternatives_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Alternatives_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0"
    // InternalEssentialOCL.g:8073:1: rule__NavigatingArgCS__Group_0_1_0__0 : rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8077:1: ( rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 )
            // InternalEssentialOCL.g:8078:2: rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingArgCS__Group_0_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0__Impl"
    // InternalEssentialOCL.g:8085:1: rule__NavigatingArgCS__Group_0_1_0__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8089:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) ) )
            // InternalEssentialOCL.g:8090:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) )
            {
            // InternalEssentialOCL.g:8090:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_0_0 ) )
            // InternalEssentialOCL.g:8091:1: ( rule__NavigatingArgCS__Alternatives_0_1_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_0_0());
            }
            // InternalEssentialOCL.g:8092:1: ( rule__NavigatingArgCS__Alternatives_0_1_0_0 )
            // InternalEssentialOCL.g:8092:2: rule__NavigatingArgCS__Alternatives_0_1_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Alternatives_0_1_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1"
    // InternalEssentialOCL.g:8102:1: rule__NavigatingArgCS__Group_0_1_0__1 : rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8106:1: ( rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 )
            // InternalEssentialOCL.g:8107:2: rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2
            {
            pushFollow(FollowSets000.FOLLOW_20);
            rule__NavigatingArgCS__Group_0_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1__Impl"
    // InternalEssentialOCL.g:8114:1: rule__NavigatingArgCS__Group_0_1_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8118:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) )
            // InternalEssentialOCL.g:8119:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) )
            {
            // InternalEssentialOCL.g:8119:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) )
            // InternalEssentialOCL.g:8120:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1());
            }
            // InternalEssentialOCL.g:8121:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 )
            // InternalEssentialOCL.g:8121:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2"
    // InternalEssentialOCL.g:8131:1: rule__NavigatingArgCS__Group_0_1_0__2 : rule__NavigatingArgCS__Group_0_1_0__2__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8135:1: ( rule__NavigatingArgCS__Group_0_1_0__2__Impl )
            // InternalEssentialOCL.g:8136:2: rule__NavigatingArgCS__Group_0_1_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2__Impl"
    // InternalEssentialOCL.g:8142:1: rule__NavigatingArgCS__Group_0_1_0__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8146:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) )
            // InternalEssentialOCL.g:8147:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            {
            // InternalEssentialOCL.g:8147:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            // InternalEssentialOCL.g:8148:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2());
            }
            // InternalEssentialOCL.g:8149:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==26) ) {
                alt70=1;
            }
            switch (alt70) {
                case 1 :
                    // InternalEssentialOCL.g:8149:2: rule__NavigatingArgCS__Group_0_1_0_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_0_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0"
    // InternalEssentialOCL.g:8165:1: rule__NavigatingArgCS__Group_0_1_0_2__0 : rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8169:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 )
            // InternalEssentialOCL.g:8170:2: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingArgCS__Group_0_1_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl"
    // InternalEssentialOCL.g:8177:1: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8181:1: ( ( '=' ) )
            // InternalEssentialOCL.g:8182:1: ( '=' )
            {
            // InternalEssentialOCL.g:8182:1: ( '=' )
            // InternalEssentialOCL.g:8183:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1"
    // InternalEssentialOCL.g:8196:1: rule__NavigatingArgCS__Group_0_1_0_2__1 : rule__NavigatingArgCS__Group_0_1_0_2__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8200:1: ( rule__NavigatingArgCS__Group_0_1_0_2__1__Impl )
            // InternalEssentialOCL.g:8201:2: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl"
    // InternalEssentialOCL.g:8207:1: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8211:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) )
            // InternalEssentialOCL.g:8212:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            {
            // InternalEssentialOCL.g:8212:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            // InternalEssentialOCL.g:8213:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1());
            }
            // InternalEssentialOCL.g:8214:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            // InternalEssentialOCL.g:8214:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0"
    // InternalEssentialOCL.g:8228:1: rule__NavigatingArgCS__Group_0_1_1__0 : rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8232:1: ( rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 )
            // InternalEssentialOCL.g:8233:2: rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingArgCS__Group_0_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0__Impl"
    // InternalEssentialOCL.g:8240:1: rule__NavigatingArgCS__Group_0_1_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8244:1: ( ( ':' ) )
            // InternalEssentialOCL.g:8245:1: ( ':' )
            {
            // InternalEssentialOCL.g:8245:1: ( ':' )
            // InternalEssentialOCL.g:8246:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1"
    // InternalEssentialOCL.g:8259:1: rule__NavigatingArgCS__Group_0_1_1__1 : rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8263:1: ( rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 )
            // InternalEssentialOCL.g:8264:2: rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__NavigatingArgCS__Group_0_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1__Impl"
    // InternalEssentialOCL.g:8271:1: rule__NavigatingArgCS__Group_0_1_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8275:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) )
            // InternalEssentialOCL.g:8276:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) )
            {
            // InternalEssentialOCL.g:8276:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) )
            // InternalEssentialOCL.g:8277:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1());
            }
            // InternalEssentialOCL.g:8278:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 )
            // InternalEssentialOCL.g:8278:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2"
    // InternalEssentialOCL.g:8288:1: rule__NavigatingArgCS__Group_0_1_1__2 : rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8292:1: ( rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 )
            // InternalEssentialOCL.g:8293:2: rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__NavigatingArgCS__Group_0_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2__Impl"
    // InternalEssentialOCL.g:8300:1: rule__NavigatingArgCS__Group_0_1_1__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8304:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) )
            // InternalEssentialOCL.g:8305:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? )
            {
            // InternalEssentialOCL.g:8305:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? )
            // InternalEssentialOCL.g:8306:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2());
            }
            // InternalEssentialOCL.g:8307:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( ((LA71_0>=55 && LA71_0<=56)) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // InternalEssentialOCL.g:8307:2: rule__NavigatingArgCS__Group_0_1_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3"
    // InternalEssentialOCL.g:8317:1: rule__NavigatingArgCS__Group_0_1_1__3 : rule__NavigatingArgCS__Group_0_1_1__3__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8321:1: ( rule__NavigatingArgCS__Group_0_1_1__3__Impl )
            // InternalEssentialOCL.g:8322:2: rule__NavigatingArgCS__Group_0_1_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__3"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3__Impl"
    // InternalEssentialOCL.g:8328:1: rule__NavigatingArgCS__Group_0_1_1__3__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8332:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) )
            // InternalEssentialOCL.g:8333:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? )
            {
            // InternalEssentialOCL.g:8333:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? )
            // InternalEssentialOCL.g:8334:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3());
            }
            // InternalEssentialOCL.g:8335:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )?
            int alt72=2;
            int LA72_0 = input.LA(1);

            if ( (LA72_0==26) ) {
                alt72=1;
            }
            switch (alt72) {
                case 1 :
                    // InternalEssentialOCL.g:8335:2: rule__NavigatingArgCS__Group_0_1_1_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__3__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0"
    // InternalEssentialOCL.g:8353:1: rule__NavigatingArgCS__Group_0_1_1_2__0 : rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8357:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 )
            // InternalEssentialOCL.g:8358:2: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingArgCS__Group_0_1_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl"
    // InternalEssentialOCL.g:8365:1: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8369:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) ) )
            // InternalEssentialOCL.g:8370:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) )
            {
            // InternalEssentialOCL.g:8370:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 ) )
            // InternalEssentialOCL.g:8371:1: ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_1_2_0());
            }
            // InternalEssentialOCL.g:8372:1: ( rule__NavigatingArgCS__Alternatives_0_1_1_2_0 )
            // InternalEssentialOCL.g:8372:2: rule__NavigatingArgCS__Alternatives_0_1_1_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Alternatives_0_1_1_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1"
    // InternalEssentialOCL.g:8382:1: rule__NavigatingArgCS__Group_0_1_1_2__1 : rule__NavigatingArgCS__Group_0_1_1_2__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8386:1: ( rule__NavigatingArgCS__Group_0_1_1_2__1__Impl )
            // InternalEssentialOCL.g:8387:2: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl"
    // InternalEssentialOCL.g:8393:1: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8397:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) )
            // InternalEssentialOCL.g:8398:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) )
            {
            // InternalEssentialOCL.g:8398:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) )
            // InternalEssentialOCL.g:8399:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1());
            }
            // InternalEssentialOCL.g:8400:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 )
            // InternalEssentialOCL.g:8400:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0"
    // InternalEssentialOCL.g:8414:1: rule__NavigatingArgCS__Group_0_1_1_3__0 : rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8418:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 )
            // InternalEssentialOCL.g:8419:2: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingArgCS__Group_0_1_1_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl"
    // InternalEssentialOCL.g:8426:1: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl : ( '=' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8430:1: ( ( '=' ) )
            // InternalEssentialOCL.g:8431:1: ( '=' )
            {
            // InternalEssentialOCL.g:8431:1: ( '=' )
            // InternalEssentialOCL.g:8432:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1"
    // InternalEssentialOCL.g:8445:1: rule__NavigatingArgCS__Group_0_1_1_3__1 : rule__NavigatingArgCS__Group_0_1_1_3__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8449:1: ( rule__NavigatingArgCS__Group_0_1_1_3__1__Impl )
            // InternalEssentialOCL.g:8450:2: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl"
    // InternalEssentialOCL.g:8456:1: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8460:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) )
            // InternalEssentialOCL.g:8461:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) )
            {
            // InternalEssentialOCL.g:8461:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) )
            // InternalEssentialOCL.g:8462:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1());
            }
            // InternalEssentialOCL.g:8463:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 )
            // InternalEssentialOCL.g:8463:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0"
    // InternalEssentialOCL.g:8477:1: rule__NavigatingArgCS__Group_0_1_2__0 : rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8481:1: ( rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 )
            // InternalEssentialOCL.g:8482:2: rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingArgCS__Group_0_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0__Impl"
    // InternalEssentialOCL.g:8489:1: rule__NavigatingArgCS__Group_0_1_2__0__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8493:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) )
            // InternalEssentialOCL.g:8494:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? )
            {
            // InternalEssentialOCL.g:8494:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? )
            // InternalEssentialOCL.g:8495:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0());
            }
            // InternalEssentialOCL.g:8496:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )?
            int alt73=2;
            int LA73_0 = input.LA(1);

            if ( (LA73_0==62) ) {
                alt73=1;
            }
            switch (alt73) {
                case 1 :
                    // InternalEssentialOCL.g:8496:2: rule__NavigatingArgCS__Group_0_1_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1"
    // InternalEssentialOCL.g:8506:1: rule__NavigatingArgCS__Group_0_1_2__1 : rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8510:1: ( rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 )
            // InternalEssentialOCL.g:8511:2: rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingArgCS__Group_0_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1__Impl"
    // InternalEssentialOCL.g:8518:1: rule__NavigatingArgCS__Group_0_1_2__1__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8522:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) )
            // InternalEssentialOCL.g:8523:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? )
            {
            // InternalEssentialOCL.g:8523:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? )
            // InternalEssentialOCL.g:8524:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1());
            }
            // InternalEssentialOCL.g:8525:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( ((LA74_0>=55 && LA74_0<=56)) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // InternalEssentialOCL.g:8525:2: rule__NavigatingArgCS__Group_0_1_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2"
    // InternalEssentialOCL.g:8535:1: rule__NavigatingArgCS__Group_0_1_2__2 : rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8539:1: ( rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 )
            // InternalEssentialOCL.g:8540:2: rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingArgCS__Group_0_1_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2__Impl"
    // InternalEssentialOCL.g:8547:1: rule__NavigatingArgCS__Group_0_1_2__2__Impl : ( 'in' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8551:1: ( ( 'in' ) )
            // InternalEssentialOCL.g:8552:1: ( 'in' )
            {
            // InternalEssentialOCL.g:8552:1: ( 'in' )
            // InternalEssentialOCL.g:8553:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2());
            }
            match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3"
    // InternalEssentialOCL.g:8566:1: rule__NavigatingArgCS__Group_0_1_2__3 : rule__NavigatingArgCS__Group_0_1_2__3__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8570:1: ( rule__NavigatingArgCS__Group_0_1_2__3__Impl )
            // InternalEssentialOCL.g:8571:2: rule__NavigatingArgCS__Group_0_1_2__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__3"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3__Impl"
    // InternalEssentialOCL.g:8577:1: rule__NavigatingArgCS__Group_0_1_2__3__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8581:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) )
            // InternalEssentialOCL.g:8582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) )
            {
            // InternalEssentialOCL.g:8582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) )
            // InternalEssentialOCL.g:8583:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3());
            }
            // InternalEssentialOCL.g:8584:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 )
            // InternalEssentialOCL.g:8584:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__3__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0"
    // InternalEssentialOCL.g:8602:1: rule__NavigatingArgCS__Group_0_1_2_0__0 : rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8606:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 )
            // InternalEssentialOCL.g:8607:2: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingArgCS__Group_0_1_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl"
    // InternalEssentialOCL.g:8614:1: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8618:1: ( ( ':' ) )
            // InternalEssentialOCL.g:8619:1: ( ':' )
            {
            // InternalEssentialOCL.g:8619:1: ( ':' )
            // InternalEssentialOCL.g:8620:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1"
    // InternalEssentialOCL.g:8633:1: rule__NavigatingArgCS__Group_0_1_2_0__1 : rule__NavigatingArgCS__Group_0_1_2_0__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8637:1: ( rule__NavigatingArgCS__Group_0_1_2_0__1__Impl )
            // InternalEssentialOCL.g:8638:2: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl"
    // InternalEssentialOCL.g:8644:1: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8648:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) )
            // InternalEssentialOCL.g:8649:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) )
            {
            // InternalEssentialOCL.g:8649:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) )
            // InternalEssentialOCL.g:8650:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1());
            }
            // InternalEssentialOCL.g:8651:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 )
            // InternalEssentialOCL.g:8651:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0"
    // InternalEssentialOCL.g:8665:1: rule__NavigatingArgCS__Group_0_1_2_1__0 : rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8669:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 )
            // InternalEssentialOCL.g:8670:2: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingArgCS__Group_0_1_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl"
    // InternalEssentialOCL.g:8677:1: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8681:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) ) )
            // InternalEssentialOCL.g:8682:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) )
            {
            // InternalEssentialOCL.g:8682:1: ( ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 ) )
            // InternalEssentialOCL.g:8683:1: ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_2_1_0());
            }
            // InternalEssentialOCL.g:8684:1: ( rule__NavigatingArgCS__Alternatives_0_1_2_1_0 )
            // InternalEssentialOCL.g:8684:2: rule__NavigatingArgCS__Alternatives_0_1_2_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Alternatives_0_1_2_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1"
    // InternalEssentialOCL.g:8694:1: rule__NavigatingArgCS__Group_0_1_2_1__1 : rule__NavigatingArgCS__Group_0_1_2_1__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8698:1: ( rule__NavigatingArgCS__Group_0_1_2_1__1__Impl )
            // InternalEssentialOCL.g:8699:2: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl"
    // InternalEssentialOCL.g:8705:1: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8709:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) )
            // InternalEssentialOCL.g:8710:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) )
            {
            // InternalEssentialOCL.g:8710:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) )
            // InternalEssentialOCL.g:8711:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1());
            }
            // InternalEssentialOCL.g:8712:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 )
            // InternalEssentialOCL.g:8712:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__0"
    // InternalEssentialOCL.g:8726:1: rule__NavigatingArgCS__Group_1__0 : rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 ;
    public final void rule__NavigatingArgCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8730:1: ( rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 )
            // InternalEssentialOCL.g:8731:2: rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingArgCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:8738:1: rule__NavigatingArgCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8742:1: ( ( ':' ) )
            // InternalEssentialOCL.g:8743:1: ( ':' )
            {
            // InternalEssentialOCL.g:8743:1: ( ':' )
            // InternalEssentialOCL.g:8744:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__1"
    // InternalEssentialOCL.g:8757:1: rule__NavigatingArgCS__Group_1__1 : rule__NavigatingArgCS__Group_1__1__Impl ;
    public final void rule__NavigatingArgCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8761:1: ( rule__NavigatingArgCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:8762:2: rule__NavigatingArgCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:8768:1: rule__NavigatingArgCS__Group_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8772:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:8773:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:8773:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            // InternalEssentialOCL.g:8774:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalEssentialOCL.g:8775:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            // InternalEssentialOCL.g:8775:2: rule__NavigatingArgCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__0"
    // InternalEssentialOCL.g:8789:1: rule__NavigatingBarArgCS__Group__0 : rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 ;
    public final void rule__NavigatingBarArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8793:1: ( rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 )
            // InternalEssentialOCL.g:8794:2: rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingBarArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__0__Impl"
    // InternalEssentialOCL.g:8801:1: rule__NavigatingBarArgCS__Group__0__Impl : ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8805:1: ( ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) )
            // InternalEssentialOCL.g:8806:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            {
            // InternalEssentialOCL.g:8806:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            // InternalEssentialOCL.g:8807:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0());
            }
            // InternalEssentialOCL.g:8808:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            // InternalEssentialOCL.g:8808:2: rule__NavigatingBarArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__1"
    // InternalEssentialOCL.g:8818:1: rule__NavigatingBarArgCS__Group__1 : rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 ;
    public final void rule__NavigatingBarArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8822:1: ( rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 )
            // InternalEssentialOCL.g:8823:2: rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_13);
            rule__NavigatingBarArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__1__Impl"
    // InternalEssentialOCL.g:8830:1: rule__NavigatingBarArgCS__Group__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8834:1: ( ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEssentialOCL.g:8835:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:8835:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEssentialOCL.g:8836:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalEssentialOCL.g:8837:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEssentialOCL.g:8837:2: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__2"
    // InternalEssentialOCL.g:8847:1: rule__NavigatingBarArgCS__Group__2 : rule__NavigatingBarArgCS__Group__2__Impl ;
    public final void rule__NavigatingBarArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8851:1: ( rule__NavigatingBarArgCS__Group__2__Impl )
            // InternalEssentialOCL.g:8852:2: rule__NavigatingBarArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__2"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__2__Impl"
    // InternalEssentialOCL.g:8858:1: rule__NavigatingBarArgCS__Group__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) ;
    public final void rule__NavigatingBarArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8862:1: ( ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:8863:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:8863:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            // InternalEssentialOCL.g:8864:1: ( rule__NavigatingBarArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:8865:1: ( rule__NavigatingBarArgCS__Group_2__0 )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==62) ) {
                alt75=1;
            }
            switch (alt75) {
                case 1 :
                    // InternalEssentialOCL.g:8865:2: rule__NavigatingBarArgCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingBarArgCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0"
    // InternalEssentialOCL.g:8881:1: rule__NavigatingBarArgCS__Group_2__0 : rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 ;
    public final void rule__NavigatingBarArgCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8885:1: ( rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 )
            // InternalEssentialOCL.g:8886:2: rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingBarArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:8893:1: rule__NavigatingBarArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingBarArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8897:1: ( ( ':' ) )
            // InternalEssentialOCL.g:8898:1: ( ':' )
            {
            // InternalEssentialOCL.g:8898:1: ( ':' )
            // InternalEssentialOCL.g:8899:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1"
    // InternalEssentialOCL.g:8912:1: rule__NavigatingBarArgCS__Group_2__1 : rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 ;
    public final void rule__NavigatingBarArgCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8916:1: ( rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 )
            // InternalEssentialOCL.g:8917:2: rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_20);
            rule__NavigatingBarArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:8924:1: rule__NavigatingBarArgCS__Group_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8928:1: ( ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:8929:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:8929:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalEssentialOCL.g:8930:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalEssentialOCL.g:8931:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            // InternalEssentialOCL.g:8931:2: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2"
    // InternalEssentialOCL.g:8941:1: rule__NavigatingBarArgCS__Group_2__2 : rule__NavigatingBarArgCS__Group_2__2__Impl ;
    public final void rule__NavigatingBarArgCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8945:1: ( rule__NavigatingBarArgCS__Group_2__2__Impl )
            // InternalEssentialOCL.g:8946:2: rule__NavigatingBarArgCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__2"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2__Impl"
    // InternalEssentialOCL.g:8952:1: rule__NavigatingBarArgCS__Group_2__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) ;
    public final void rule__NavigatingBarArgCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8956:1: ( ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) )
            // InternalEssentialOCL.g:8957:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            {
            // InternalEssentialOCL.g:8957:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            // InternalEssentialOCL.g:8958:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2());
            }
            // InternalEssentialOCL.g:8959:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==26) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // InternalEssentialOCL.g:8959:2: rule__NavigatingBarArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingBarArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__2__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0"
    // InternalEssentialOCL.g:8975:1: rule__NavigatingBarArgCS__Group_2_2__0 : rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 ;
    public final void rule__NavigatingBarArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8979:1: ( rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 )
            // InternalEssentialOCL.g:8980:2: rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingBarArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0__Impl"
    // InternalEssentialOCL.g:8987:1: rule__NavigatingBarArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingBarArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:8991:1: ( ( '=' ) )
            // InternalEssentialOCL.g:8992:1: ( '=' )
            {
            // InternalEssentialOCL.g:8992:1: ( '=' )
            // InternalEssentialOCL.g:8993:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1"
    // InternalEssentialOCL.g:9006:1: rule__NavigatingBarArgCS__Group_2_2__1 : rule__NavigatingBarArgCS__Group_2_2__1__Impl ;
    public final void rule__NavigatingBarArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9010:1: ( rule__NavigatingBarArgCS__Group_2_2__1__Impl )
            // InternalEssentialOCL.g:9011:2: rule__NavigatingBarArgCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1__Impl"
    // InternalEssentialOCL.g:9017:1: rule__NavigatingBarArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9021:1: ( ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalEssentialOCL.g:9022:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalEssentialOCL.g:9022:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalEssentialOCL.g:9023:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }
            // InternalEssentialOCL.g:9024:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalEssentialOCL.g:9024:2: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__0"
    // InternalEssentialOCL.g:9038:1: rule__NavigatingCommaArgCS__Group__0 : rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 ;
    public final void rule__NavigatingCommaArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9042:1: ( rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 )
            // InternalEssentialOCL.g:9043:2: rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingCommaArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__0__Impl"
    // InternalEssentialOCL.g:9050:1: rule__NavigatingCommaArgCS__Group__0__Impl : ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9054:1: ( ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) )
            // InternalEssentialOCL.g:9055:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            {
            // InternalEssentialOCL.g:9055:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            // InternalEssentialOCL.g:9056:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0());
            }
            // InternalEssentialOCL.g:9057:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            // InternalEssentialOCL.g:9057:2: rule__NavigatingCommaArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__1"
    // InternalEssentialOCL.g:9067:1: rule__NavigatingCommaArgCS__Group__1 : rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 ;
    public final void rule__NavigatingCommaArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9071:1: ( rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 )
            // InternalEssentialOCL.g:9072:2: rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingCommaArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__1__Impl"
    // InternalEssentialOCL.g:9079:1: rule__NavigatingCommaArgCS__Group__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9083:1: ( ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEssentialOCL.g:9084:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:9084:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEssentialOCL.g:9085:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalEssentialOCL.g:9086:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEssentialOCL.g:9086:2: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__2"
    // InternalEssentialOCL.g:9096:1: rule__NavigatingCommaArgCS__Group__2 : rule__NavigatingCommaArgCS__Group__2__Impl ;
    public final void rule__NavigatingCommaArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9100:1: ( rule__NavigatingCommaArgCS__Group__2__Impl )
            // InternalEssentialOCL.g:9101:2: rule__NavigatingCommaArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__2__Impl"
    // InternalEssentialOCL.g:9107:1: rule__NavigatingCommaArgCS__Group__2__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9111:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) )
            // InternalEssentialOCL.g:9112:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            {
            // InternalEssentialOCL.g:9112:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            // InternalEssentialOCL.g:9113:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2());
            }
            // InternalEssentialOCL.g:9114:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            int alt77=2;
            int LA77_0 = input.LA(1);

            if ( ((LA77_0>=55 && LA77_0<=56)||LA77_0==62||LA77_0==73) ) {
                alt77=1;
            }
            switch (alt77) {
                case 1 :
                    // InternalEssentialOCL.g:9114:2: rule__NavigatingCommaArgCS__Alternatives_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0"
    // InternalEssentialOCL.g:9130:1: rule__NavigatingCommaArgCS__Group_2_0__0 : rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9134:1: ( rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 )
            // InternalEssentialOCL.g:9135:2: rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingCommaArgCS__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0__Impl"
    // InternalEssentialOCL.g:9142:1: rule__NavigatingCommaArgCS__Group_2_0__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9146:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) ) )
            // InternalEssentialOCL.g:9147:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) )
            {
            // InternalEssentialOCL.g:9147:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 ) )
            // InternalEssentialOCL.g:9148:1: ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_0_0());
            }
            // InternalEssentialOCL.g:9149:1: ( rule__NavigatingCommaArgCS__Alternatives_2_0_0 )
            // InternalEssentialOCL.g:9149:2: rule__NavigatingCommaArgCS__Alternatives_2_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Alternatives_2_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1"
    // InternalEssentialOCL.g:9159:1: rule__NavigatingCommaArgCS__Group_2_0__1 : rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9163:1: ( rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 )
            // InternalEssentialOCL.g:9164:2: rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2
            {
            pushFollow(FollowSets000.FOLLOW_20);
            rule__NavigatingCommaArgCS__Group_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1__Impl"
    // InternalEssentialOCL.g:9171:1: rule__NavigatingCommaArgCS__Group_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9175:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) )
            // InternalEssentialOCL.g:9176:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) )
            {
            // InternalEssentialOCL.g:9176:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) )
            // InternalEssentialOCL.g:9177:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1());
            }
            // InternalEssentialOCL.g:9178:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 )
            // InternalEssentialOCL.g:9178:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2"
    // InternalEssentialOCL.g:9188:1: rule__NavigatingCommaArgCS__Group_2_0__2 : rule__NavigatingCommaArgCS__Group_2_0__2__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9192:1: ( rule__NavigatingCommaArgCS__Group_2_0__2__Impl )
            // InternalEssentialOCL.g:9193:2: rule__NavigatingCommaArgCS__Group_2_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2__Impl"
    // InternalEssentialOCL.g:9199:1: rule__NavigatingCommaArgCS__Group_2_0__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9203:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) )
            // InternalEssentialOCL.g:9204:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            {
            // InternalEssentialOCL.g:9204:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            // InternalEssentialOCL.g:9205:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2());
            }
            // InternalEssentialOCL.g:9206:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            int alt78=2;
            int LA78_0 = input.LA(1);

            if ( (LA78_0==26) ) {
                alt78=1;
            }
            switch (alt78) {
                case 1 :
                    // InternalEssentialOCL.g:9206:2: rule__NavigatingCommaArgCS__Group_2_0_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_0_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0"
    // InternalEssentialOCL.g:9222:1: rule__NavigatingCommaArgCS__Group_2_0_2__0 : rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9226:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 )
            // InternalEssentialOCL.g:9227:2: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl"
    // InternalEssentialOCL.g:9234:1: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9238:1: ( ( '=' ) )
            // InternalEssentialOCL.g:9239:1: ( '=' )
            {
            // InternalEssentialOCL.g:9239:1: ( '=' )
            // InternalEssentialOCL.g:9240:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1"
    // InternalEssentialOCL.g:9253:1: rule__NavigatingCommaArgCS__Group_2_0_2__1 : rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9257:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl )
            // InternalEssentialOCL.g:9258:2: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl"
    // InternalEssentialOCL.g:9264:1: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9268:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) )
            // InternalEssentialOCL.g:9269:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            {
            // InternalEssentialOCL.g:9269:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            // InternalEssentialOCL.g:9270:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1());
            }
            // InternalEssentialOCL.g:9271:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            // InternalEssentialOCL.g:9271:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0"
    // InternalEssentialOCL.g:9285:1: rule__NavigatingCommaArgCS__Group_2_1__0 : rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9289:1: ( rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 )
            // InternalEssentialOCL.g:9290:2: rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingCommaArgCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0__Impl"
    // InternalEssentialOCL.g:9297:1: rule__NavigatingCommaArgCS__Group_2_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9301:1: ( ( ':' ) )
            // InternalEssentialOCL.g:9302:1: ( ':' )
            {
            // InternalEssentialOCL.g:9302:1: ( ':' )
            // InternalEssentialOCL.g:9303:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1"
    // InternalEssentialOCL.g:9316:1: rule__NavigatingCommaArgCS__Group_2_1__1 : rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9320:1: ( rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 )
            // InternalEssentialOCL.g:9321:2: rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__NavigatingCommaArgCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1__Impl"
    // InternalEssentialOCL.g:9328:1: rule__NavigatingCommaArgCS__Group_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9332:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) )
            // InternalEssentialOCL.g:9333:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) )
            {
            // InternalEssentialOCL.g:9333:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) )
            // InternalEssentialOCL.g:9334:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1());
            }
            // InternalEssentialOCL.g:9335:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 )
            // InternalEssentialOCL.g:9335:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2"
    // InternalEssentialOCL.g:9345:1: rule__NavigatingCommaArgCS__Group_2_1__2 : rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9349:1: ( rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 )
            // InternalEssentialOCL.g:9350:2: rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__NavigatingCommaArgCS__Group_2_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2__Impl"
    // InternalEssentialOCL.g:9357:1: rule__NavigatingCommaArgCS__Group_2_1__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9361:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) )
            // InternalEssentialOCL.g:9362:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? )
            {
            // InternalEssentialOCL.g:9362:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? )
            // InternalEssentialOCL.g:9363:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2());
            }
            // InternalEssentialOCL.g:9364:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )?
            int alt79=2;
            int LA79_0 = input.LA(1);

            if ( ((LA79_0>=55 && LA79_0<=56)) ) {
                alt79=1;
            }
            switch (alt79) {
                case 1 :
                    // InternalEssentialOCL.g:9364:2: rule__NavigatingCommaArgCS__Group_2_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3"
    // InternalEssentialOCL.g:9374:1: rule__NavigatingCommaArgCS__Group_2_1__3 : rule__NavigatingCommaArgCS__Group_2_1__3__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9378:1: ( rule__NavigatingCommaArgCS__Group_2_1__3__Impl )
            // InternalEssentialOCL.g:9379:2: rule__NavigatingCommaArgCS__Group_2_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3__Impl"
    // InternalEssentialOCL.g:9385:1: rule__NavigatingCommaArgCS__Group_2_1__3__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9389:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) )
            // InternalEssentialOCL.g:9390:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? )
            {
            // InternalEssentialOCL.g:9390:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? )
            // InternalEssentialOCL.g:9391:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3());
            }
            // InternalEssentialOCL.g:9392:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )?
            int alt80=2;
            int LA80_0 = input.LA(1);

            if ( (LA80_0==26) ) {
                alt80=1;
            }
            switch (alt80) {
                case 1 :
                    // InternalEssentialOCL.g:9392:2: rule__NavigatingCommaArgCS__Group_2_1_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0"
    // InternalEssentialOCL.g:9410:1: rule__NavigatingCommaArgCS__Group_2_1_2__0 : rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9414:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 )
            // InternalEssentialOCL.g:9415:2: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl"
    // InternalEssentialOCL.g:9422:1: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9426:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) ) )
            // InternalEssentialOCL.g:9427:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) )
            {
            // InternalEssentialOCL.g:9427:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 ) )
            // InternalEssentialOCL.g:9428:1: ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_1_2_0());
            }
            // InternalEssentialOCL.g:9429:1: ( rule__NavigatingCommaArgCS__Alternatives_2_1_2_0 )
            // InternalEssentialOCL.g:9429:2: rule__NavigatingCommaArgCS__Alternatives_2_1_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Alternatives_2_1_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1"
    // InternalEssentialOCL.g:9439:1: rule__NavigatingCommaArgCS__Group_2_1_2__1 : rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9443:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl )
            // InternalEssentialOCL.g:9444:2: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl"
    // InternalEssentialOCL.g:9450:1: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9454:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) )
            // InternalEssentialOCL.g:9455:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) )
            {
            // InternalEssentialOCL.g:9455:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) )
            // InternalEssentialOCL.g:9456:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1());
            }
            // InternalEssentialOCL.g:9457:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 )
            // InternalEssentialOCL.g:9457:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0"
    // InternalEssentialOCL.g:9471:1: rule__NavigatingCommaArgCS__Group_2_1_3__0 : rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9475:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 )
            // InternalEssentialOCL.g:9476:2: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl"
    // InternalEssentialOCL.g:9483:1: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl : ( '=' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9487:1: ( ( '=' ) )
            // InternalEssentialOCL.g:9488:1: ( '=' )
            {
            // InternalEssentialOCL.g:9488:1: ( '=' )
            // InternalEssentialOCL.g:9489:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1"
    // InternalEssentialOCL.g:9502:1: rule__NavigatingCommaArgCS__Group_2_1_3__1 : rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9506:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl )
            // InternalEssentialOCL.g:9507:2: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl"
    // InternalEssentialOCL.g:9513:1: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9517:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) )
            // InternalEssentialOCL.g:9518:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) )
            {
            // InternalEssentialOCL.g:9518:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) )
            // InternalEssentialOCL.g:9519:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1());
            }
            // InternalEssentialOCL.g:9520:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 )
            // InternalEssentialOCL.g:9520:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0"
    // InternalEssentialOCL.g:9534:1: rule__NavigatingCommaArgCS__Group_2_2__0 : rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9538:1: ( rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 )
            // InternalEssentialOCL.g:9539:2: rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingCommaArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0__Impl"
    // InternalEssentialOCL.g:9546:1: rule__NavigatingCommaArgCS__Group_2_2__0__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9550:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) )
            // InternalEssentialOCL.g:9551:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? )
            {
            // InternalEssentialOCL.g:9551:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? )
            // InternalEssentialOCL.g:9552:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0());
            }
            // InternalEssentialOCL.g:9553:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )?
            int alt81=2;
            int LA81_0 = input.LA(1);

            if ( (LA81_0==62) ) {
                alt81=1;
            }
            switch (alt81) {
                case 1 :
                    // InternalEssentialOCL.g:9553:2: rule__NavigatingCommaArgCS__Group_2_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1"
    // InternalEssentialOCL.g:9563:1: rule__NavigatingCommaArgCS__Group_2_2__1 : rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9567:1: ( rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 )
            // InternalEssentialOCL.g:9568:2: rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__NavigatingCommaArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1__Impl"
    // InternalEssentialOCL.g:9575:1: rule__NavigatingCommaArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9579:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) )
            // InternalEssentialOCL.g:9580:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? )
            {
            // InternalEssentialOCL.g:9580:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? )
            // InternalEssentialOCL.g:9581:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1());
            }
            // InternalEssentialOCL.g:9582:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )?
            int alt82=2;
            int LA82_0 = input.LA(1);

            if ( ((LA82_0>=55 && LA82_0<=56)) ) {
                alt82=1;
            }
            switch (alt82) {
                case 1 :
                    // InternalEssentialOCL.g:9582:2: rule__NavigatingCommaArgCS__Group_2_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2"
    // InternalEssentialOCL.g:9592:1: rule__NavigatingCommaArgCS__Group_2_2__2 : rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9596:1: ( rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 )
            // InternalEssentialOCL.g:9597:2: rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingCommaArgCS__Group_2_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2__Impl"
    // InternalEssentialOCL.g:9604:1: rule__NavigatingCommaArgCS__Group_2_2__2__Impl : ( 'in' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9608:1: ( ( 'in' ) )
            // InternalEssentialOCL.g:9609:1: ( 'in' )
            {
            // InternalEssentialOCL.g:9609:1: ( 'in' )
            // InternalEssentialOCL.g:9610:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2());
            }
            match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3"
    // InternalEssentialOCL.g:9623:1: rule__NavigatingCommaArgCS__Group_2_2__3 : rule__NavigatingCommaArgCS__Group_2_2__3__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9627:1: ( rule__NavigatingCommaArgCS__Group_2_2__3__Impl )
            // InternalEssentialOCL.g:9628:2: rule__NavigatingCommaArgCS__Group_2_2__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3__Impl"
    // InternalEssentialOCL.g:9634:1: rule__NavigatingCommaArgCS__Group_2_2__3__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9638:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) )
            // InternalEssentialOCL.g:9639:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) )
            {
            // InternalEssentialOCL.g:9639:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) )
            // InternalEssentialOCL.g:9640:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3());
            }
            // InternalEssentialOCL.g:9641:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 )
            // InternalEssentialOCL.g:9641:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0"
    // InternalEssentialOCL.g:9659:1: rule__NavigatingCommaArgCS__Group_2_2_0__0 : rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9663:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 )
            // InternalEssentialOCL.g:9664:2: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl"
    // InternalEssentialOCL.g:9671:1: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9675:1: ( ( ':' ) )
            // InternalEssentialOCL.g:9676:1: ( ':' )
            {
            // InternalEssentialOCL.g:9676:1: ( ':' )
            // InternalEssentialOCL.g:9677:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1"
    // InternalEssentialOCL.g:9690:1: rule__NavigatingCommaArgCS__Group_2_2_0__1 : rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9694:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl )
            // InternalEssentialOCL.g:9695:2: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl"
    // InternalEssentialOCL.g:9701:1: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9705:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) )
            // InternalEssentialOCL.g:9706:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) )
            {
            // InternalEssentialOCL.g:9706:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) )
            // InternalEssentialOCL.g:9707:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1());
            }
            // InternalEssentialOCL.g:9708:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 )
            // InternalEssentialOCL.g:9708:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0"
    // InternalEssentialOCL.g:9722:1: rule__NavigatingCommaArgCS__Group_2_2_1__0 : rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9726:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 )
            // InternalEssentialOCL.g:9727:2: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl"
    // InternalEssentialOCL.g:9734:1: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9738:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) ) )
            // InternalEssentialOCL.g:9739:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) )
            {
            // InternalEssentialOCL.g:9739:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 ) )
            // InternalEssentialOCL.g:9740:1: ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_2_1_0());
            }
            // InternalEssentialOCL.g:9741:1: ( rule__NavigatingCommaArgCS__Alternatives_2_2_1_0 )
            // InternalEssentialOCL.g:9741:2: rule__NavigatingCommaArgCS__Alternatives_2_2_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Alternatives_2_2_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1"
    // InternalEssentialOCL.g:9751:1: rule__NavigatingCommaArgCS__Group_2_2_1__1 : rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9755:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl )
            // InternalEssentialOCL.g:9756:2: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl"
    // InternalEssentialOCL.g:9762:1: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9766:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) )
            // InternalEssentialOCL.g:9767:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) )
            {
            // InternalEssentialOCL.g:9767:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) )
            // InternalEssentialOCL.g:9768:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1());
            }
            // InternalEssentialOCL.g:9769:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 )
            // InternalEssentialOCL.g:9769:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__0"
    // InternalEssentialOCL.g:9783:1: rule__NavigatingSemiArgCS__Group__0 : rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 ;
    public final void rule__NavigatingSemiArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9787:1: ( rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 )
            // InternalEssentialOCL.g:9788:2: rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingSemiArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__0__Impl"
    // InternalEssentialOCL.g:9795:1: rule__NavigatingSemiArgCS__Group__0__Impl : ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9799:1: ( ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) )
            // InternalEssentialOCL.g:9800:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            {
            // InternalEssentialOCL.g:9800:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            // InternalEssentialOCL.g:9801:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0());
            }
            // InternalEssentialOCL.g:9802:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            // InternalEssentialOCL.g:9802:2: rule__NavigatingSemiArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__1"
    // InternalEssentialOCL.g:9812:1: rule__NavigatingSemiArgCS__Group__1 : rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 ;
    public final void rule__NavigatingSemiArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9816:1: ( rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 )
            // InternalEssentialOCL.g:9817:2: rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_13);
            rule__NavigatingSemiArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__1__Impl"
    // InternalEssentialOCL.g:9824:1: rule__NavigatingSemiArgCS__Group__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9828:1: ( ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEssentialOCL.g:9829:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:9829:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEssentialOCL.g:9830:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalEssentialOCL.g:9831:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEssentialOCL.g:9831:2: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__2"
    // InternalEssentialOCL.g:9841:1: rule__NavigatingSemiArgCS__Group__2 : rule__NavigatingSemiArgCS__Group__2__Impl ;
    public final void rule__NavigatingSemiArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9845:1: ( rule__NavigatingSemiArgCS__Group__2__Impl )
            // InternalEssentialOCL.g:9846:2: rule__NavigatingSemiArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__2"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__2__Impl"
    // InternalEssentialOCL.g:9852:1: rule__NavigatingSemiArgCS__Group__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) ;
    public final void rule__NavigatingSemiArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9856:1: ( ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:9857:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:9857:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            // InternalEssentialOCL.g:9858:1: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:9859:1: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            int alt83=2;
            int LA83_0 = input.LA(1);

            if ( (LA83_0==62) ) {
                alt83=1;
            }
            switch (alt83) {
                case 1 :
                    // InternalEssentialOCL.g:9859:2: rule__NavigatingSemiArgCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingSemiArgCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0"
    // InternalEssentialOCL.g:9875:1: rule__NavigatingSemiArgCS__Group_2__0 : rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 ;
    public final void rule__NavigatingSemiArgCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9879:1: ( rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 )
            // InternalEssentialOCL.g:9880:2: rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__NavigatingSemiArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:9887:1: rule__NavigatingSemiArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9891:1: ( ( ':' ) )
            // InternalEssentialOCL.g:9892:1: ( ':' )
            {
            // InternalEssentialOCL.g:9892:1: ( ':' )
            // InternalEssentialOCL.g:9893:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1"
    // InternalEssentialOCL.g:9906:1: rule__NavigatingSemiArgCS__Group_2__1 : rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 ;
    public final void rule__NavigatingSemiArgCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9910:1: ( rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 )
            // InternalEssentialOCL.g:9911:2: rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_20);
            rule__NavigatingSemiArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:9918:1: rule__NavigatingSemiArgCS__Group_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9922:1: ( ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:9923:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:9923:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalEssentialOCL.g:9924:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalEssentialOCL.g:9925:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            // InternalEssentialOCL.g:9925:2: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2"
    // InternalEssentialOCL.g:9935:1: rule__NavigatingSemiArgCS__Group_2__2 : rule__NavigatingSemiArgCS__Group_2__2__Impl ;
    public final void rule__NavigatingSemiArgCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9939:1: ( rule__NavigatingSemiArgCS__Group_2__2__Impl )
            // InternalEssentialOCL.g:9940:2: rule__NavigatingSemiArgCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__2"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2__Impl"
    // InternalEssentialOCL.g:9946:1: rule__NavigatingSemiArgCS__Group_2__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9950:1: ( ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) )
            // InternalEssentialOCL.g:9951:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            {
            // InternalEssentialOCL.g:9951:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            // InternalEssentialOCL.g:9952:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2());
            }
            // InternalEssentialOCL.g:9953:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            int alt84=2;
            int LA84_0 = input.LA(1);

            if ( (LA84_0==26) ) {
                alt84=1;
            }
            switch (alt84) {
                case 1 :
                    // InternalEssentialOCL.g:9953:2: rule__NavigatingSemiArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingSemiArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__2__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0"
    // InternalEssentialOCL.g:9969:1: rule__NavigatingSemiArgCS__Group_2_2__0 : rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9973:1: ( rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 )
            // InternalEssentialOCL.g:9974:2: rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NavigatingSemiArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0__Impl"
    // InternalEssentialOCL.g:9981:1: rule__NavigatingSemiArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:9985:1: ( ( '=' ) )
            // InternalEssentialOCL.g:9986:1: ( '=' )
            {
            // InternalEssentialOCL.g:9986:1: ( '=' )
            // InternalEssentialOCL.g:9987:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1"
    // InternalEssentialOCL.g:10000:1: rule__NavigatingSemiArgCS__Group_2_2__1 : rule__NavigatingSemiArgCS__Group_2_2__1__Impl ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10004:1: ( rule__NavigatingSemiArgCS__Group_2_2__1__Impl )
            // InternalEssentialOCL.g:10005:2: rule__NavigatingSemiArgCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1__Impl"
    // InternalEssentialOCL.g:10011:1: rule__NavigatingSemiArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10015:1: ( ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalEssentialOCL.g:10016:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalEssentialOCL.g:10016:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalEssentialOCL.g:10017:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }
            // InternalEssentialOCL.g:10018:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalEssentialOCL.g:10018:2: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__0"
    // InternalEssentialOCL.g:10032:1: rule__CoIteratorVariableCS__Group__0 : rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 ;
    public final void rule__CoIteratorVariableCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10036:1: ( rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 )
            // InternalEssentialOCL.g:10037:2: rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_13);
            rule__CoIteratorVariableCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__0"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__0__Impl"
    // InternalEssentialOCL.g:10044:1: rule__CoIteratorVariableCS__Group__0__Impl : ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) ;
    public final void rule__CoIteratorVariableCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10048:1: ( ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:10049:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:10049:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:10050:1: ( rule__CoIteratorVariableCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:10051:1: ( rule__CoIteratorVariableCS__NameAssignment_0 )
            // InternalEssentialOCL.g:10051:2: rule__CoIteratorVariableCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__0__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__1"
    // InternalEssentialOCL.g:10061:1: rule__CoIteratorVariableCS__Group__1 : rule__CoIteratorVariableCS__Group__1__Impl ;
    public final void rule__CoIteratorVariableCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10065:1: ( rule__CoIteratorVariableCS__Group__1__Impl )
            // InternalEssentialOCL.g:10066:2: rule__CoIteratorVariableCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__1"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__1__Impl"
    // InternalEssentialOCL.g:10072:1: rule__CoIteratorVariableCS__Group__1__Impl : ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) ;
    public final void rule__CoIteratorVariableCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10076:1: ( ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:10077:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:10077:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? )
            // InternalEssentialOCL.g:10078:1: ( rule__CoIteratorVariableCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:10079:1: ( rule__CoIteratorVariableCS__Group_1__0 )?
            int alt85=2;
            int LA85_0 = input.LA(1);

            if ( (LA85_0==62) ) {
                alt85=1;
            }
            switch (alt85) {
                case 1 :
                    // InternalEssentialOCL.g:10079:2: rule__CoIteratorVariableCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CoIteratorVariableCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__1__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0"
    // InternalEssentialOCL.g:10093:1: rule__CoIteratorVariableCS__Group_1__0 : rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 ;
    public final void rule__CoIteratorVariableCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10097:1: ( rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 )
            // InternalEssentialOCL.g:10098:2: rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__CoIteratorVariableCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:10105:1: rule__CoIteratorVariableCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__CoIteratorVariableCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10109:1: ( ( ':' ) )
            // InternalEssentialOCL.g:10110:1: ( ':' )
            {
            // InternalEssentialOCL.g:10110:1: ( ':' )
            // InternalEssentialOCL.g:10111:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1"
    // InternalEssentialOCL.g:10124:1: rule__CoIteratorVariableCS__Group_1__1 : rule__CoIteratorVariableCS__Group_1__1__Impl ;
    public final void rule__CoIteratorVariableCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10128:1: ( rule__CoIteratorVariableCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:10129:2: rule__CoIteratorVariableCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__1"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:10135:1: rule__CoIteratorVariableCS__Group_1__1__Impl : ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__CoIteratorVariableCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10139:1: ( ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:10140:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:10140:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) )
            // InternalEssentialOCL.g:10141:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalEssentialOCL.g:10142:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 )
            // InternalEssentialOCL.g:10142:2: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__1__Impl"


    // $ANTLR start "rule__IfExpCS__Group__0"
    // InternalEssentialOCL.g:10156:1: rule__IfExpCS__Group__0 : rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 ;
    public final void rule__IfExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10160:1: ( rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 )
            // InternalEssentialOCL.g:10161:2: rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_16);
            rule__IfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__0"


    // $ANTLR start "rule__IfExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:10168:1: rule__IfExpCS__Group__0__Impl : ( 'if' ) ;
    public final void rule__IfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10172:1: ( ( 'if' ) )
            // InternalEssentialOCL.g:10173:1: ( 'if' )
            {
            // InternalEssentialOCL.g:10173:1: ( 'if' )
            // InternalEssentialOCL.g:10174:1: 'if'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getIfKeyword_0());
            }
            match(input,74,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getIfKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__0__Impl"


    // $ANTLR start "rule__IfExpCS__Group__1"
    // InternalEssentialOCL.g:10187:1: rule__IfExpCS__Group__1 : rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 ;
    public final void rule__IfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10191:1: ( rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 )
            // InternalEssentialOCL.g:10192:2: rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_44);
            rule__IfExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__1"


    // $ANTLR start "rule__IfExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:10199:1: rule__IfExpCS__Group__1__Impl : ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__IfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10203:1: ( ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalEssentialOCL.g:10204:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:10204:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            // InternalEssentialOCL.g:10205:1: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1());
            }
            // InternalEssentialOCL.g:10206:1: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            // InternalEssentialOCL.g:10206:2: rule__IfExpCS__OwnedConditionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedConditionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__1__Impl"


    // $ANTLR start "rule__IfExpCS__Group__2"
    // InternalEssentialOCL.g:10216:1: rule__IfExpCS__Group__2 : rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 ;
    public final void rule__IfExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10220:1: ( rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 )
            // InternalEssentialOCL.g:10221:2: rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__IfExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__2"


    // $ANTLR start "rule__IfExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:10228:1: rule__IfExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__IfExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10232:1: ( ( 'then' ) )
            // InternalEssentialOCL.g:10233:1: ( 'then' )
            {
            // InternalEssentialOCL.g:10233:1: ( 'then' )
            // InternalEssentialOCL.g:10234:1: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getThenKeyword_2());
            }
            match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getThenKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__2__Impl"


    // $ANTLR start "rule__IfExpCS__Group__3"
    // InternalEssentialOCL.g:10247:1: rule__IfExpCS__Group__3 : rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 ;
    public final void rule__IfExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10251:1: ( rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 )
            // InternalEssentialOCL.g:10252:2: rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_45);
            rule__IfExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__3"


    // $ANTLR start "rule__IfExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:10259:1: rule__IfExpCS__Group__3__Impl : ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__IfExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10263:1: ( ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalEssentialOCL.g:10264:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalEssentialOCL.g:10264:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalEssentialOCL.g:10265:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3());
            }
            // InternalEssentialOCL.g:10266:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            // InternalEssentialOCL.g:10266:2: rule__IfExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedThenExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__3__Impl"


    // $ANTLR start "rule__IfExpCS__Group__4"
    // InternalEssentialOCL.g:10276:1: rule__IfExpCS__Group__4 : rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 ;
    public final void rule__IfExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10280:1: ( rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 )
            // InternalEssentialOCL.g:10281:2: rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_45);
            rule__IfExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__4"


    // $ANTLR start "rule__IfExpCS__Group__4__Impl"
    // InternalEssentialOCL.g:10288:1: rule__IfExpCS__Group__4__Impl : ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) ;
    public final void rule__IfExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10292:1: ( ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) )
            // InternalEssentialOCL.g:10293:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            {
            // InternalEssentialOCL.g:10293:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            // InternalEssentialOCL.g:10294:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4());
            }
            // InternalEssentialOCL.g:10295:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            loop86:
            do {
                int alt86=2;
                int LA86_0 = input.LA(1);

                if ( (LA86_0==78) ) {
                    alt86=1;
                }


                switch (alt86) {
            	case 1 :
            	    // InternalEssentialOCL.g:10295:2: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4
            	    {
            	    pushFollow(FollowSets000.FOLLOW_46);
            	    rule__IfExpCS__OwnedIfThenExpressionsAssignment_4();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__4__Impl"


    // $ANTLR start "rule__IfExpCS__Group__5"
    // InternalEssentialOCL.g:10305:1: rule__IfExpCS__Group__5 : rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 ;
    public final void rule__IfExpCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10309:1: ( rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 )
            // InternalEssentialOCL.g:10310:2: rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__IfExpCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__5"


    // $ANTLR start "rule__IfExpCS__Group__5__Impl"
    // InternalEssentialOCL.g:10317:1: rule__IfExpCS__Group__5__Impl : ( 'else' ) ;
    public final void rule__IfExpCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10321:1: ( ( 'else' ) )
            // InternalEssentialOCL.g:10322:1: ( 'else' )
            {
            // InternalEssentialOCL.g:10322:1: ( 'else' )
            // InternalEssentialOCL.g:10323:1: 'else'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getElseKeyword_5());
            }
            match(input,76,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getElseKeyword_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__5__Impl"


    // $ANTLR start "rule__IfExpCS__Group__6"
    // InternalEssentialOCL.g:10336:1: rule__IfExpCS__Group__6 : rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 ;
    public final void rule__IfExpCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10340:1: ( rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 )
            // InternalEssentialOCL.g:10341:2: rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7
            {
            pushFollow(FollowSets000.FOLLOW_47);
            rule__IfExpCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__6"


    // $ANTLR start "rule__IfExpCS__Group__6__Impl"
    // InternalEssentialOCL.g:10348:1: rule__IfExpCS__Group__6__Impl : ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) ;
    public final void rule__IfExpCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10352:1: ( ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) )
            // InternalEssentialOCL.g:10353:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            {
            // InternalEssentialOCL.g:10353:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            // InternalEssentialOCL.g:10354:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6());
            }
            // InternalEssentialOCL.g:10355:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            // InternalEssentialOCL.g:10355:2: rule__IfExpCS__OwnedElseExpressionAssignment_6
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedElseExpressionAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__6__Impl"


    // $ANTLR start "rule__IfExpCS__Group__7"
    // InternalEssentialOCL.g:10365:1: rule__IfExpCS__Group__7 : rule__IfExpCS__Group__7__Impl ;
    public final void rule__IfExpCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10369:1: ( rule__IfExpCS__Group__7__Impl )
            // InternalEssentialOCL.g:10370:2: rule__IfExpCS__Group__7__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__7"


    // $ANTLR start "rule__IfExpCS__Group__7__Impl"
    // InternalEssentialOCL.g:10376:1: rule__IfExpCS__Group__7__Impl : ( 'endif' ) ;
    public final void rule__IfExpCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10380:1: ( ( 'endif' ) )
            // InternalEssentialOCL.g:10381:1: ( 'endif' )
            {
            // InternalEssentialOCL.g:10381:1: ( 'endif' )
            // InternalEssentialOCL.g:10382:1: 'endif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getEndifKeyword_7());
            }
            match(input,77,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getEndifKeyword_7());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__7__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__0"
    // InternalEssentialOCL.g:10411:1: rule__ElseIfThenExpCS__Group__0 : rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 ;
    public final void rule__ElseIfThenExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10415:1: ( rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 )
            // InternalEssentialOCL.g:10416:2: rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ElseIfThenExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__0"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:10423:1: rule__ElseIfThenExpCS__Group__0__Impl : ( 'elseif' ) ;
    public final void rule__ElseIfThenExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10427:1: ( ( 'elseif' ) )
            // InternalEssentialOCL.g:10428:1: ( 'elseif' )
            {
            // InternalEssentialOCL.g:10428:1: ( 'elseif' )
            // InternalEssentialOCL.g:10429:1: 'elseif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0());
            }
            match(input,78,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__0__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__1"
    // InternalEssentialOCL.g:10442:1: rule__ElseIfThenExpCS__Group__1 : rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 ;
    public final void rule__ElseIfThenExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10446:1: ( rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 )
            // InternalEssentialOCL.g:10447:2: rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_44);
            rule__ElseIfThenExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__1"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:10454:1: rule__ElseIfThenExpCS__Group__1__Impl : ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10458:1: ( ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalEssentialOCL.g:10459:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:10459:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            // InternalEssentialOCL.g:10460:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1());
            }
            // InternalEssentialOCL.g:10461:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            // InternalEssentialOCL.g:10461:2: rule__ElseIfThenExpCS__OwnedConditionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__OwnedConditionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__1__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__2"
    // InternalEssentialOCL.g:10471:1: rule__ElseIfThenExpCS__Group__2 : rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 ;
    public final void rule__ElseIfThenExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10475:1: ( rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 )
            // InternalEssentialOCL.g:10476:2: rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ElseIfThenExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__2"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:10483:1: rule__ElseIfThenExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__ElseIfThenExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10487:1: ( ( 'then' ) )
            // InternalEssentialOCL.g:10488:1: ( 'then' )
            {
            // InternalEssentialOCL.g:10488:1: ( 'then' )
            // InternalEssentialOCL.g:10489:1: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2());
            }
            match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__2__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__3"
    // InternalEssentialOCL.g:10502:1: rule__ElseIfThenExpCS__Group__3 : rule__ElseIfThenExpCS__Group__3__Impl ;
    public final void rule__ElseIfThenExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10506:1: ( rule__ElseIfThenExpCS__Group__3__Impl )
            // InternalEssentialOCL.g:10507:2: rule__ElseIfThenExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__3"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:10513:1: rule__ElseIfThenExpCS__Group__3__Impl : ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10517:1: ( ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalEssentialOCL.g:10518:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalEssentialOCL.g:10518:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalEssentialOCL.g:10519:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3());
            }
            // InternalEssentialOCL.g:10520:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            // InternalEssentialOCL.g:10520:2: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__3__Impl"


    // $ANTLR start "rule__LetExpCS__Group__0"
    // InternalEssentialOCL.g:10538:1: rule__LetExpCS__Group__0 : rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 ;
    public final void rule__LetExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10542:1: ( rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 )
            // InternalEssentialOCL.g:10543:2: rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__LetExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__0"


    // $ANTLR start "rule__LetExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:10550:1: rule__LetExpCS__Group__0__Impl : ( 'let' ) ;
    public final void rule__LetExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10554:1: ( ( 'let' ) )
            // InternalEssentialOCL.g:10555:1: ( 'let' )
            {
            // InternalEssentialOCL.g:10555:1: ( 'let' )
            // InternalEssentialOCL.g:10556:1: 'let'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetKeyword_0());
            }
            match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__0__Impl"


    // $ANTLR start "rule__LetExpCS__Group__1"
    // InternalEssentialOCL.g:10569:1: rule__LetExpCS__Group__1 : rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 ;
    public final void rule__LetExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10573:1: ( rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 )
            // InternalEssentialOCL.g:10574:2: rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_48);
            rule__LetExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__1"


    // $ANTLR start "rule__LetExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:10581:1: rule__LetExpCS__Group__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) ;
    public final void rule__LetExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10585:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) )
            // InternalEssentialOCL.g:10586:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            {
            // InternalEssentialOCL.g:10586:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            // InternalEssentialOCL.g:10587:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1());
            }
            // InternalEssentialOCL.g:10588:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            // InternalEssentialOCL.g:10588:2: rule__LetExpCS__OwnedVariablesAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedVariablesAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__1__Impl"


    // $ANTLR start "rule__LetExpCS__Group__2"
    // InternalEssentialOCL.g:10598:1: rule__LetExpCS__Group__2 : rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 ;
    public final void rule__LetExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10602:1: ( rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 )
            // InternalEssentialOCL.g:10603:2: rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_48);
            rule__LetExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__2"


    // $ANTLR start "rule__LetExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:10610:1: rule__LetExpCS__Group__2__Impl : ( ( rule__LetExpCS__Group_2__0 )* ) ;
    public final void rule__LetExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10614:1: ( ( ( rule__LetExpCS__Group_2__0 )* ) )
            // InternalEssentialOCL.g:10615:1: ( ( rule__LetExpCS__Group_2__0 )* )
            {
            // InternalEssentialOCL.g:10615:1: ( ( rule__LetExpCS__Group_2__0 )* )
            // InternalEssentialOCL.g:10616:1: ( rule__LetExpCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:10617:1: ( rule__LetExpCS__Group_2__0 )*
            loop87:
            do {
                int alt87=2;
                int LA87_0 = input.LA(1);

                if ( (LA87_0==61) ) {
                    alt87=1;
                }


                switch (alt87) {
            	case 1 :
            	    // InternalEssentialOCL.g:10617:2: rule__LetExpCS__Group_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__LetExpCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__2__Impl"


    // $ANTLR start "rule__LetExpCS__Group__3"
    // InternalEssentialOCL.g:10627:1: rule__LetExpCS__Group__3 : rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 ;
    public final void rule__LetExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10631:1: ( rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 )
            // InternalEssentialOCL.g:10632:2: rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__LetExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__3"


    // $ANTLR start "rule__LetExpCS__Group__3__Impl"
    // InternalEssentialOCL.g:10639:1: rule__LetExpCS__Group__3__Impl : ( 'in' ) ;
    public final void rule__LetExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10643:1: ( ( 'in' ) )
            // InternalEssentialOCL.g:10644:1: ( 'in' )
            {
            // InternalEssentialOCL.g:10644:1: ( 'in' )
            // InternalEssentialOCL.g:10645:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInKeyword_3());
            }
            match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getInKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__3__Impl"


    // $ANTLR start "rule__LetExpCS__Group__4"
    // InternalEssentialOCL.g:10658:1: rule__LetExpCS__Group__4 : rule__LetExpCS__Group__4__Impl ;
    public final void rule__LetExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10662:1: ( rule__LetExpCS__Group__4__Impl )
            // InternalEssentialOCL.g:10663:2: rule__LetExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__4"


    // $ANTLR start "rule__LetExpCS__Group__4__Impl"
    // InternalEssentialOCL.g:10669:1: rule__LetExpCS__Group__4__Impl : ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) ;
    public final void rule__LetExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10673:1: ( ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) )
            // InternalEssentialOCL.g:10674:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            {
            // InternalEssentialOCL.g:10674:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            // InternalEssentialOCL.g:10675:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4());
            }
            // InternalEssentialOCL.g:10676:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            // InternalEssentialOCL.g:10676:2: rule__LetExpCS__OwnedInExpressionAssignment_4
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedInExpressionAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__4__Impl"


    // $ANTLR start "rule__LetExpCS__Group_2__0"
    // InternalEssentialOCL.g:10696:1: rule__LetExpCS__Group_2__0 : rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 ;
    public final void rule__LetExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10700:1: ( rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 )
            // InternalEssentialOCL.g:10701:2: rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__LetExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__0"


    // $ANTLR start "rule__LetExpCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:10708:1: rule__LetExpCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__LetExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10712:1: ( ( ',' ) )
            // InternalEssentialOCL.g:10713:1: ( ',' )
            {
            // InternalEssentialOCL.g:10713:1: ( ',' )
            // InternalEssentialOCL.g:10714:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__LetExpCS__Group_2__1"
    // InternalEssentialOCL.g:10727:1: rule__LetExpCS__Group_2__1 : rule__LetExpCS__Group_2__1__Impl ;
    public final void rule__LetExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10731:1: ( rule__LetExpCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:10732:2: rule__LetExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__1"


    // $ANTLR start "rule__LetExpCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:10738:1: rule__LetExpCS__Group_2__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) ;
    public final void rule__LetExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10742:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:10743:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:10743:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            // InternalEssentialOCL.g:10744:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1());
            }
            // InternalEssentialOCL.g:10745:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            // InternalEssentialOCL.g:10745:2: rule__LetExpCS__OwnedVariablesAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedVariablesAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__0"
    // InternalEssentialOCL.g:10759:1: rule__LetVariableCS__Group__0 : rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 ;
    public final void rule__LetVariableCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10763:1: ( rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 )
            // InternalEssentialOCL.g:10764:2: rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_49);
            rule__LetVariableCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__0"


    // $ANTLR start "rule__LetVariableCS__Group__0__Impl"
    // InternalEssentialOCL.g:10771:1: rule__LetVariableCS__Group__0__Impl : ( ( rule__LetVariableCS__NameAssignment_0 ) ) ;
    public final void rule__LetVariableCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10775:1: ( ( ( rule__LetVariableCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:10776:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:10776:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:10777:1: ( rule__LetVariableCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:10778:1: ( rule__LetVariableCS__NameAssignment_0 )
            // InternalEssentialOCL.g:10778:2: rule__LetVariableCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__0__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__1"
    // InternalEssentialOCL.g:10788:1: rule__LetVariableCS__Group__1 : rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 ;
    public final void rule__LetVariableCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10792:1: ( rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 )
            // InternalEssentialOCL.g:10793:2: rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_49);
            rule__LetVariableCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__1"


    // $ANTLR start "rule__LetVariableCS__Group__1__Impl"
    // InternalEssentialOCL.g:10800:1: rule__LetVariableCS__Group__1__Impl : ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) ;
    public final void rule__LetVariableCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10804:1: ( ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) )
            // InternalEssentialOCL.g:10805:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            {
            // InternalEssentialOCL.g:10805:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            // InternalEssentialOCL.g:10806:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1());
            }
            // InternalEssentialOCL.g:10807:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            int alt88=2;
            int LA88_0 = input.LA(1);

            if ( (LA88_0==59) ) {
                alt88=1;
            }
            switch (alt88) {
                case 1 :
                    // InternalEssentialOCL.g:10807:2: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__1__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__2"
    // InternalEssentialOCL.g:10817:1: rule__LetVariableCS__Group__2 : rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 ;
    public final void rule__LetVariableCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10821:1: ( rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 )
            // InternalEssentialOCL.g:10822:2: rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_49);
            rule__LetVariableCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__2"


    // $ANTLR start "rule__LetVariableCS__Group__2__Impl"
    // InternalEssentialOCL.g:10829:1: rule__LetVariableCS__Group__2__Impl : ( ( rule__LetVariableCS__Group_2__0 )? ) ;
    public final void rule__LetVariableCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10833:1: ( ( ( rule__LetVariableCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:10834:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:10834:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            // InternalEssentialOCL.g:10835:1: ( rule__LetVariableCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:10836:1: ( rule__LetVariableCS__Group_2__0 )?
            int alt89=2;
            int LA89_0 = input.LA(1);

            if ( (LA89_0==62) ) {
                alt89=1;
            }
            switch (alt89) {
                case 1 :
                    // InternalEssentialOCL.g:10836:2: rule__LetVariableCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__LetVariableCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__2__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__3"
    // InternalEssentialOCL.g:10846:1: rule__LetVariableCS__Group__3 : rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 ;
    public final void rule__LetVariableCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10850:1: ( rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 )
            // InternalEssentialOCL.g:10851:2: rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__LetVariableCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__3"


    // $ANTLR start "rule__LetVariableCS__Group__3__Impl"
    // InternalEssentialOCL.g:10858:1: rule__LetVariableCS__Group__3__Impl : ( '=' ) ;
    public final void rule__LetVariableCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10862:1: ( ( '=' ) )
            // InternalEssentialOCL.g:10863:1: ( '=' )
            {
            // InternalEssentialOCL.g:10863:1: ( '=' )
            // InternalEssentialOCL.g:10864:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3());
            }
            match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__3__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__4"
    // InternalEssentialOCL.g:10877:1: rule__LetVariableCS__Group__4 : rule__LetVariableCS__Group__4__Impl ;
    public final void rule__LetVariableCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10881:1: ( rule__LetVariableCS__Group__4__Impl )
            // InternalEssentialOCL.g:10882:2: rule__LetVariableCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__4"


    // $ANTLR start "rule__LetVariableCS__Group__4__Impl"
    // InternalEssentialOCL.g:10888:1: rule__LetVariableCS__Group__4__Impl : ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) ;
    public final void rule__LetVariableCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10892:1: ( ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) )
            // InternalEssentialOCL.g:10893:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            {
            // InternalEssentialOCL.g:10893:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            // InternalEssentialOCL.g:10894:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4());
            }
            // InternalEssentialOCL.g:10895:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            // InternalEssentialOCL.g:10895:2: rule__LetVariableCS__OwnedInitExpressionAssignment_4
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__OwnedInitExpressionAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__4__Impl"


    // $ANTLR start "rule__LetVariableCS__Group_2__0"
    // InternalEssentialOCL.g:10915:1: rule__LetVariableCS__Group_2__0 : rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 ;
    public final void rule__LetVariableCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10919:1: ( rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 )
            // InternalEssentialOCL.g:10920:2: rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__LetVariableCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__0"


    // $ANTLR start "rule__LetVariableCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:10927:1: rule__LetVariableCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__LetVariableCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10931:1: ( ( ':' ) )
            // InternalEssentialOCL.g:10932:1: ( ':' )
            {
            // InternalEssentialOCL.g:10932:1: ( ':' )
            // InternalEssentialOCL.g:10933:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__0__Impl"


    // $ANTLR start "rule__LetVariableCS__Group_2__1"
    // InternalEssentialOCL.g:10946:1: rule__LetVariableCS__Group_2__1 : rule__LetVariableCS__Group_2__1__Impl ;
    public final void rule__LetVariableCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10950:1: ( rule__LetVariableCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:10951:2: rule__LetVariableCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__1"


    // $ANTLR start "rule__LetVariableCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:10957:1: rule__LetVariableCS__Group_2__1__Impl : ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__LetVariableCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10961:1: ( ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:10962:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:10962:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            // InternalEssentialOCL.g:10963:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalEssentialOCL.g:10964:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            // InternalEssentialOCL.g:10964:2: rule__LetVariableCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__1__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__0"
    // InternalEssentialOCL.g:10978:1: rule__NestedExpCS__Group__0 : rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 ;
    public final void rule__NestedExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10982:1: ( rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 )
            // InternalEssentialOCL.g:10983:2: rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__NestedExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__0"


    // $ANTLR start "rule__NestedExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:10990:1: rule__NestedExpCS__Group__0__Impl : ( '(' ) ;
    public final void rule__NestedExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:10994:1: ( ( '(' ) )
            // InternalEssentialOCL.g:10995:1: ( '(' )
            {
            // InternalEssentialOCL.g:10995:1: ( '(' )
            // InternalEssentialOCL.g:10996:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__0__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__1"
    // InternalEssentialOCL.g:11009:1: rule__NestedExpCS__Group__1 : rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 ;
    public final void rule__NestedExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11013:1: ( rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 )
            // InternalEssentialOCL.g:11014:2: rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NestedExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__1"


    // $ANTLR start "rule__NestedExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:11021:1: rule__NestedExpCS__Group__1__Impl : ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) ;
    public final void rule__NestedExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11025:1: ( ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) )
            // InternalEssentialOCL.g:11026:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            {
            // InternalEssentialOCL.g:11026:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            // InternalEssentialOCL.g:11027:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1());
            }
            // InternalEssentialOCL.g:11028:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            // InternalEssentialOCL.g:11028:2: rule__NestedExpCS__OwnedExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__OwnedExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__1__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__2"
    // InternalEssentialOCL.g:11038:1: rule__NestedExpCS__Group__2 : rule__NestedExpCS__Group__2__Impl ;
    public final void rule__NestedExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11042:1: ( rule__NestedExpCS__Group__2__Impl )
            // InternalEssentialOCL.g:11043:2: rule__NestedExpCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__2"


    // $ANTLR start "rule__NestedExpCS__Group__2__Impl"
    // InternalEssentialOCL.g:11049:1: rule__NestedExpCS__Group__2__Impl : ( ')' ) ;
    public final void rule__NestedExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11053:1: ( ( ')' ) )
            // InternalEssentialOCL.g:11054:1: ( ')' )
            {
            // InternalEssentialOCL.g:11054:1: ( ')' )
            // InternalEssentialOCL.g:11055:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__2__Impl"


    // $ANTLR start "rule__SelfExpCS__Group__0"
    // InternalEssentialOCL.g:11074:1: rule__SelfExpCS__Group__0 : rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 ;
    public final void rule__SelfExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11078:1: ( rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 )
            // InternalEssentialOCL.g:11079:2: rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__SelfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__0"


    // $ANTLR start "rule__SelfExpCS__Group__0__Impl"
    // InternalEssentialOCL.g:11086:1: rule__SelfExpCS__Group__0__Impl : ( () ) ;
    public final void rule__SelfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11090:1: ( ( () ) )
            // InternalEssentialOCL.g:11091:1: ( () )
            {
            // InternalEssentialOCL.g:11091:1: ( () )
            // InternalEssentialOCL.g:11092:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0());
            }
            // InternalEssentialOCL.g:11093:1: ()
            // InternalEssentialOCL.g:11095:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__0__Impl"


    // $ANTLR start "rule__SelfExpCS__Group__1"
    // InternalEssentialOCL.g:11105:1: rule__SelfExpCS__Group__1 : rule__SelfExpCS__Group__1__Impl ;
    public final void rule__SelfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11109:1: ( rule__SelfExpCS__Group__1__Impl )
            // InternalEssentialOCL.g:11110:2: rule__SelfExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__1"


    // $ANTLR start "rule__SelfExpCS__Group__1__Impl"
    // InternalEssentialOCL.g:11116:1: rule__SelfExpCS__Group__1__Impl : ( 'self' ) ;
    public final void rule__SelfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11120:1: ( ( 'self' ) )
            // InternalEssentialOCL.g:11121:1: ( 'self' )
            {
            // InternalEssentialOCL.g:11121:1: ( 'self' )
            // InternalEssentialOCL.g:11122:1: 'self'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1());
            }
            match(input,80,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__0"
    // InternalEssentialOCL.g:11139:1: rule__MultiplicityBoundsCS__Group__0 : rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 ;
    public final void rule__MultiplicityBoundsCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11143:1: ( rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 )
            // InternalEssentialOCL.g:11144:2: rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__MultiplicityBoundsCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__0"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__0__Impl"
    // InternalEssentialOCL.g:11151:1: rule__MultiplicityBoundsCS__Group__0__Impl : ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) ;
    public final void rule__MultiplicityBoundsCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11155:1: ( ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) )
            // InternalEssentialOCL.g:11156:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            {
            // InternalEssentialOCL.g:11156:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            // InternalEssentialOCL.g:11157:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0());
            }
            // InternalEssentialOCL.g:11158:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            // InternalEssentialOCL.g:11158:2: rule__MultiplicityBoundsCS__LowerBoundAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__LowerBoundAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__0__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__1"
    // InternalEssentialOCL.g:11168:1: rule__MultiplicityBoundsCS__Group__1 : rule__MultiplicityBoundsCS__Group__1__Impl ;
    public final void rule__MultiplicityBoundsCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11172:1: ( rule__MultiplicityBoundsCS__Group__1__Impl )
            // InternalEssentialOCL.g:11173:2: rule__MultiplicityBoundsCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__1"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__1__Impl"
    // InternalEssentialOCL.g:11179:1: rule__MultiplicityBoundsCS__Group__1__Impl : ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) ;
    public final void rule__MultiplicityBoundsCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11183:1: ( ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:11184:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:11184:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            // InternalEssentialOCL.g:11185:1: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:11186:1: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            int alt90=2;
            int LA90_0 = input.LA(1);

            if ( (LA90_0==65) ) {
                alt90=1;
            }
            switch (alt90) {
                case 1 :
                    // InternalEssentialOCL.g:11186:2: rule__MultiplicityBoundsCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityBoundsCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0"
    // InternalEssentialOCL.g:11200:1: rule__MultiplicityBoundsCS__Group_1__0 : rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 ;
    public final void rule__MultiplicityBoundsCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11204:1: ( rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 )
            // InternalEssentialOCL.g:11205:2: rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_51);
            rule__MultiplicityBoundsCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:11212:1: rule__MultiplicityBoundsCS__Group_1__0__Impl : ( '..' ) ;
    public final void rule__MultiplicityBoundsCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11216:1: ( ( '..' ) )
            // InternalEssentialOCL.g:11217:1: ( '..' )
            {
            // InternalEssentialOCL.g:11217:1: ( '..' )
            // InternalEssentialOCL.g:11218:1: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0());
            }
            match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1"
    // InternalEssentialOCL.g:11231:1: rule__MultiplicityBoundsCS__Group_1__1 : rule__MultiplicityBoundsCS__Group_1__1__Impl ;
    public final void rule__MultiplicityBoundsCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11235:1: ( rule__MultiplicityBoundsCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:11236:2: rule__MultiplicityBoundsCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__1"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:11242:1: rule__MultiplicityBoundsCS__Group_1__1__Impl : ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) ;
    public final void rule__MultiplicityBoundsCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11246:1: ( ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:11247:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:11247:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            // InternalEssentialOCL.g:11248:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1());
            }
            // InternalEssentialOCL.g:11249:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            // InternalEssentialOCL.g:11249:2: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__1__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__0"
    // InternalEssentialOCL.g:11263:1: rule__MultiplicityCS__Group__0 : rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 ;
    public final void rule__MultiplicityCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11267:1: ( rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 )
            // InternalEssentialOCL.g:11268:2: rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_52);
            rule__MultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__0"


    // $ANTLR start "rule__MultiplicityCS__Group__0__Impl"
    // InternalEssentialOCL.g:11275:1: rule__MultiplicityCS__Group__0__Impl : ( '[' ) ;
    public final void rule__MultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11279:1: ( ( '[' ) )
            // InternalEssentialOCL.g:11280:1: ( '[' )
            {
            // InternalEssentialOCL.g:11280:1: ( '[' )
            // InternalEssentialOCL.g:11281:1: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__0__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__1"
    // InternalEssentialOCL.g:11294:1: rule__MultiplicityCS__Group__1 : rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 ;
    public final void rule__MultiplicityCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11298:1: ( rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 )
            // InternalEssentialOCL.g:11299:2: rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_53);
            rule__MultiplicityCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__1"


    // $ANTLR start "rule__MultiplicityCS__Group__1__Impl"
    // InternalEssentialOCL.g:11306:1: rule__MultiplicityCS__Group__1__Impl : ( ( rule__MultiplicityCS__Alternatives_1 ) ) ;
    public final void rule__MultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11310:1: ( ( ( rule__MultiplicityCS__Alternatives_1 ) ) )
            // InternalEssentialOCL.g:11311:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            {
            // InternalEssentialOCL.g:11311:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            // InternalEssentialOCL.g:11312:1: ( rule__MultiplicityCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1());
            }
            // InternalEssentialOCL.g:11313:1: ( rule__MultiplicityCS__Alternatives_1 )
            // InternalEssentialOCL.g:11313:2: rule__MultiplicityCS__Alternatives_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Alternatives_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getAlternatives_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__2"
    // InternalEssentialOCL.g:11323:1: rule__MultiplicityCS__Group__2 : rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 ;
    public final void rule__MultiplicityCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11327:1: ( rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 )
            // InternalEssentialOCL.g:11328:2: rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_53);
            rule__MultiplicityCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__2"


    // $ANTLR start "rule__MultiplicityCS__Group__2__Impl"
    // InternalEssentialOCL.g:11335:1: rule__MultiplicityCS__Group__2__Impl : ( ( rule__MultiplicityCS__Alternatives_2 )? ) ;
    public final void rule__MultiplicityCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11339:1: ( ( ( rule__MultiplicityCS__Alternatives_2 )? ) )
            // InternalEssentialOCL.g:11340:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            {
            // InternalEssentialOCL.g:11340:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            // InternalEssentialOCL.g:11341:1: ( rule__MultiplicityCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_2());
            }
            // InternalEssentialOCL.g:11342:1: ( rule__MultiplicityCS__Alternatives_2 )?
            int alt91=2;
            int LA91_0 = input.LA(1);

            if ( (LA91_0==57||LA91_0==89) ) {
                alt91=1;
            }
            switch (alt91) {
                case 1 :
                    // InternalEssentialOCL.g:11342:2: rule__MultiplicityCS__Alternatives_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityCS__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getAlternatives_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__2__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__3"
    // InternalEssentialOCL.g:11352:1: rule__MultiplicityCS__Group__3 : rule__MultiplicityCS__Group__3__Impl ;
    public final void rule__MultiplicityCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11356:1: ( rule__MultiplicityCS__Group__3__Impl )
            // InternalEssentialOCL.g:11357:2: rule__MultiplicityCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__3"


    // $ANTLR start "rule__MultiplicityCS__Group__3__Impl"
    // InternalEssentialOCL.g:11363:1: rule__MultiplicityCS__Group__3__Impl : ( ']' ) ;
    public final void rule__MultiplicityCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11367:1: ( ( ']' ) )
            // InternalEssentialOCL.g:11368:1: ( ']' )
            {
            // InternalEssentialOCL.g:11368:1: ( ']' )
            // InternalEssentialOCL.g:11369:1: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__3__Impl"


    // $ANTLR start "rule__PathNameCS__Group__0"
    // InternalEssentialOCL.g:11390:1: rule__PathNameCS__Group__0 : rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 ;
    public final void rule__PathNameCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11394:1: ( rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 )
            // InternalEssentialOCL.g:11395:2: rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_54);
            rule__PathNameCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__0"


    // $ANTLR start "rule__PathNameCS__Group__0__Impl"
    // InternalEssentialOCL.g:11402:1: rule__PathNameCS__Group__0__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) ;
    public final void rule__PathNameCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11406:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) )
            // InternalEssentialOCL.g:11407:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            {
            // InternalEssentialOCL.g:11407:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            // InternalEssentialOCL.g:11408:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0());
            }
            // InternalEssentialOCL.g:11409:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            // InternalEssentialOCL.g:11409:2: rule__PathNameCS__OwnedPathElementsAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__OwnedPathElementsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__0__Impl"


    // $ANTLR start "rule__PathNameCS__Group__1"
    // InternalEssentialOCL.g:11419:1: rule__PathNameCS__Group__1 : rule__PathNameCS__Group__1__Impl ;
    public final void rule__PathNameCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11423:1: ( rule__PathNameCS__Group__1__Impl )
            // InternalEssentialOCL.g:11424:2: rule__PathNameCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__1"


    // $ANTLR start "rule__PathNameCS__Group__1__Impl"
    // InternalEssentialOCL.g:11430:1: rule__PathNameCS__Group__1__Impl : ( ( rule__PathNameCS__Group_1__0 )* ) ;
    public final void rule__PathNameCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11434:1: ( ( ( rule__PathNameCS__Group_1__0 )* ) )
            // InternalEssentialOCL.g:11435:1: ( ( rule__PathNameCS__Group_1__0 )* )
            {
            // InternalEssentialOCL.g:11435:1: ( ( rule__PathNameCS__Group_1__0 )* )
            // InternalEssentialOCL.g:11436:1: ( rule__PathNameCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:11437:1: ( rule__PathNameCS__Group_1__0 )*
            loop92:
            do {
                int alt92=2;
                int LA92_0 = input.LA(1);

                if ( (LA92_0==81) ) {
                    alt92=1;
                }


                switch (alt92) {
            	case 1 :
            	    // InternalEssentialOCL.g:11437:2: rule__PathNameCS__Group_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_55);
            	    rule__PathNameCS__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__1__Impl"


    // $ANTLR start "rule__PathNameCS__Group_1__0"
    // InternalEssentialOCL.g:11451:1: rule__PathNameCS__Group_1__0 : rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 ;
    public final void rule__PathNameCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11455:1: ( rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 )
            // InternalEssentialOCL.g:11456:2: rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__PathNameCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__0"


    // $ANTLR start "rule__PathNameCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:11463:1: rule__PathNameCS__Group_1__0__Impl : ( '::' ) ;
    public final void rule__PathNameCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11467:1: ( ( '::' ) )
            // InternalEssentialOCL.g:11468:1: ( '::' )
            {
            // InternalEssentialOCL.g:11468:1: ( '::' )
            // InternalEssentialOCL.g:11469:1: '::'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0());
            }
            match(input,81,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__0__Impl"


    // $ANTLR start "rule__PathNameCS__Group_1__1"
    // InternalEssentialOCL.g:11482:1: rule__PathNameCS__Group_1__1 : rule__PathNameCS__Group_1__1__Impl ;
    public final void rule__PathNameCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11486:1: ( rule__PathNameCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:11487:2: rule__PathNameCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__1"


    // $ANTLR start "rule__PathNameCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:11493:1: rule__PathNameCS__Group_1__1__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) ;
    public final void rule__PathNameCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11497:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:11498:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:11498:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            // InternalEssentialOCL.g:11499:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1());
            }
            // InternalEssentialOCL.g:11500:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            // InternalEssentialOCL.g:11500:2: rule__PathNameCS__OwnedPathElementsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__OwnedPathElementsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__1__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__0"
    // InternalEssentialOCL.g:11516:1: rule__TemplateBindingCS__Group__0 : rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 ;
    public final void rule__TemplateBindingCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11520:1: ( rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 )
            // InternalEssentialOCL.g:11521:2: rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_56);
            rule__TemplateBindingCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__0"


    // $ANTLR start "rule__TemplateBindingCS__Group__0__Impl"
    // InternalEssentialOCL.g:11528:1: rule__TemplateBindingCS__Group__0__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) ;
    public final void rule__TemplateBindingCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11532:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) )
            // InternalEssentialOCL.g:11533:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            {
            // InternalEssentialOCL.g:11533:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            // InternalEssentialOCL.g:11534:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0());
            }
            // InternalEssentialOCL.g:11535:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            // InternalEssentialOCL.g:11535:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__0__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__1"
    // InternalEssentialOCL.g:11545:1: rule__TemplateBindingCS__Group__1 : rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 ;
    public final void rule__TemplateBindingCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11549:1: ( rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 )
            // InternalEssentialOCL.g:11550:2: rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_56);
            rule__TemplateBindingCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__1"


    // $ANTLR start "rule__TemplateBindingCS__Group__1__Impl"
    // InternalEssentialOCL.g:11557:1: rule__TemplateBindingCS__Group__1__Impl : ( ( rule__TemplateBindingCS__Group_1__0 )* ) ;
    public final void rule__TemplateBindingCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11561:1: ( ( ( rule__TemplateBindingCS__Group_1__0 )* ) )
            // InternalEssentialOCL.g:11562:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            {
            // InternalEssentialOCL.g:11562:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            // InternalEssentialOCL.g:11563:1: ( rule__TemplateBindingCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:11564:1: ( rule__TemplateBindingCS__Group_1__0 )*
            loop93:
            do {
                int alt93=2;
                int LA93_0 = input.LA(1);

                if ( (LA93_0==61) ) {
                    alt93=1;
                }


                switch (alt93) {
            	case 1 :
            	    // InternalEssentialOCL.g:11564:2: rule__TemplateBindingCS__Group_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_11);
            	    rule__TemplateBindingCS__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__1__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__2"
    // InternalEssentialOCL.g:11574:1: rule__TemplateBindingCS__Group__2 : rule__TemplateBindingCS__Group__2__Impl ;
    public final void rule__TemplateBindingCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11578:1: ( rule__TemplateBindingCS__Group__2__Impl )
            // InternalEssentialOCL.g:11579:2: rule__TemplateBindingCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__2"


    // $ANTLR start "rule__TemplateBindingCS__Group__2__Impl"
    // InternalEssentialOCL.g:11585:1: rule__TemplateBindingCS__Group__2__Impl : ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) ;
    public final void rule__TemplateBindingCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11589:1: ( ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) )
            // InternalEssentialOCL.g:11590:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            {
            // InternalEssentialOCL.g:11590:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            // InternalEssentialOCL.g:11591:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2());
            }
            // InternalEssentialOCL.g:11592:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( (LA94_0==71) ) {
                alt94=1;
            }
            switch (alt94) {
                case 1 :
                    // InternalEssentialOCL.g:11592:2: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TemplateBindingCS__OwnedMultiplicityAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__2__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__0"
    // InternalEssentialOCL.g:11608:1: rule__TemplateBindingCS__Group_1__0 : rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 ;
    public final void rule__TemplateBindingCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11612:1: ( rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 )
            // InternalEssentialOCL.g:11613:2: rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__TemplateBindingCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__0"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:11620:1: rule__TemplateBindingCS__Group_1__0__Impl : ( ',' ) ;
    public final void rule__TemplateBindingCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11624:1: ( ( ',' ) )
            // InternalEssentialOCL.g:11625:1: ( ',' )
            {
            // InternalEssentialOCL.g:11625:1: ( ',' )
            // InternalEssentialOCL.g:11626:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__0__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__1"
    // InternalEssentialOCL.g:11639:1: rule__TemplateBindingCS__Group_1__1 : rule__TemplateBindingCS__Group_1__1__Impl ;
    public final void rule__TemplateBindingCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11643:1: ( rule__TemplateBindingCS__Group_1__1__Impl )
            // InternalEssentialOCL.g:11644:2: rule__TemplateBindingCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__1"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:11650:1: rule__TemplateBindingCS__Group_1__1__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) ;
    public final void rule__TemplateBindingCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11654:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:11655:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:11655:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            // InternalEssentialOCL.g:11656:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1());
            }
            // InternalEssentialOCL.g:11657:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            // InternalEssentialOCL.g:11657:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group__0"
    // InternalEssentialOCL.g:11673:1: rule__TypeParameterCS__Group__0 : rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 ;
    public final void rule__TypeParameterCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11677:1: ( rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 )
            // InternalEssentialOCL.g:11678:2: rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__TypeParameterCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__0"


    // $ANTLR start "rule__TypeParameterCS__Group__0__Impl"
    // InternalEssentialOCL.g:11685:1: rule__TypeParameterCS__Group__0__Impl : ( ( rule__TypeParameterCS__NameAssignment_0 ) ) ;
    public final void rule__TypeParameterCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11689:1: ( ( ( rule__TypeParameterCS__NameAssignment_0 ) ) )
            // InternalEssentialOCL.g:11690:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:11690:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            // InternalEssentialOCL.g:11691:1: ( rule__TypeParameterCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0());
            }
            // InternalEssentialOCL.g:11692:1: ( rule__TypeParameterCS__NameAssignment_0 )
            // InternalEssentialOCL.g:11692:2: rule__TypeParameterCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group__1"
    // InternalEssentialOCL.g:11702:1: rule__TypeParameterCS__Group__1 : rule__TypeParameterCS__Group__1__Impl ;
    public final void rule__TypeParameterCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11706:1: ( rule__TypeParameterCS__Group__1__Impl )
            // InternalEssentialOCL.g:11707:2: rule__TypeParameterCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__1"


    // $ANTLR start "rule__TypeParameterCS__Group__1__Impl"
    // InternalEssentialOCL.g:11713:1: rule__TypeParameterCS__Group__1__Impl : ( ( rule__TypeParameterCS__Group_1__0 )? ) ;
    public final void rule__TypeParameterCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11717:1: ( ( ( rule__TypeParameterCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:11718:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:11718:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            // InternalEssentialOCL.g:11719:1: ( rule__TypeParameterCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:11720:1: ( rule__TypeParameterCS__Group_1__0 )?
            int alt95=2;
            int LA95_0 = input.LA(1);

            if ( (LA95_0==82) ) {
                alt95=1;
            }
            switch (alt95) {
                case 1 :
                    // InternalEssentialOCL.g:11720:2: rule__TypeParameterCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeParameterCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__0"
    // InternalEssentialOCL.g:11734:1: rule__TypeParameterCS__Group_1__0 : rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 ;
    public final void rule__TypeParameterCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11738:1: ( rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 )
            // InternalEssentialOCL.g:11739:2: rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TypeParameterCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__0"


    // $ANTLR start "rule__TypeParameterCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:11746:1: rule__TypeParameterCS__Group_1__0__Impl : ( 'extends' ) ;
    public final void rule__TypeParameterCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11750:1: ( ( 'extends' ) )
            // InternalEssentialOCL.g:11751:1: ( 'extends' )
            {
            // InternalEssentialOCL.g:11751:1: ( 'extends' )
            // InternalEssentialOCL.g:11752:1: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0());
            }
            match(input,82,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__1"
    // InternalEssentialOCL.g:11765:1: rule__TypeParameterCS__Group_1__1 : rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 ;
    public final void rule__TypeParameterCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11769:1: ( rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 )
            // InternalEssentialOCL.g:11770:2: rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_59);
            rule__TypeParameterCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__1"


    // $ANTLR start "rule__TypeParameterCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:11777:1: rule__TypeParameterCS__Group_1__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) ;
    public final void rule__TypeParameterCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11781:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:11782:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:11782:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            // InternalEssentialOCL.g:11783:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1());
            }
            // InternalEssentialOCL.g:11784:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            // InternalEssentialOCL.g:11784:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__OwnedExtendsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__2"
    // InternalEssentialOCL.g:11794:1: rule__TypeParameterCS__Group_1__2 : rule__TypeParameterCS__Group_1__2__Impl ;
    public final void rule__TypeParameterCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11798:1: ( rule__TypeParameterCS__Group_1__2__Impl )
            // InternalEssentialOCL.g:11799:2: rule__TypeParameterCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__2"


    // $ANTLR start "rule__TypeParameterCS__Group_1__2__Impl"
    // InternalEssentialOCL.g:11805:1: rule__TypeParameterCS__Group_1__2__Impl : ( ( rule__TypeParameterCS__Group_1_2__0 )* ) ;
    public final void rule__TypeParameterCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11809:1: ( ( ( rule__TypeParameterCS__Group_1_2__0 )* ) )
            // InternalEssentialOCL.g:11810:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            {
            // InternalEssentialOCL.g:11810:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            // InternalEssentialOCL.g:11811:1: ( rule__TypeParameterCS__Group_1_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1_2());
            }
            // InternalEssentialOCL.g:11812:1: ( rule__TypeParameterCS__Group_1_2__0 )*
            loop96:
            do {
                int alt96=2;
                int LA96_0 = input.LA(1);

                if ( (LA96_0==83) ) {
                    alt96=1;
                }


                switch (alt96) {
            	case 1 :
            	    // InternalEssentialOCL.g:11812:2: rule__TypeParameterCS__Group_1_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_60);
            	    rule__TypeParameterCS__Group_1_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getGroup_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__2__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__0"
    // InternalEssentialOCL.g:11828:1: rule__TypeParameterCS__Group_1_2__0 : rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 ;
    public final void rule__TypeParameterCS__Group_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11832:1: ( rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 )
            // InternalEssentialOCL.g:11833:2: rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TypeParameterCS__Group_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__0"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__0__Impl"
    // InternalEssentialOCL.g:11840:1: rule__TypeParameterCS__Group_1_2__0__Impl : ( '&&' ) ;
    public final void rule__TypeParameterCS__Group_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11844:1: ( ( '&&' ) )
            // InternalEssentialOCL.g:11845:1: ( '&&' )
            {
            // InternalEssentialOCL.g:11845:1: ( '&&' )
            // InternalEssentialOCL.g:11846:1: '&&'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__1"
    // InternalEssentialOCL.g:11859:1: rule__TypeParameterCS__Group_1_2__1 : rule__TypeParameterCS__Group_1_2__1__Impl ;
    public final void rule__TypeParameterCS__Group_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11863:1: ( rule__TypeParameterCS__Group_1_2__1__Impl )
            // InternalEssentialOCL.g:11864:2: rule__TypeParameterCS__Group_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__1"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__1__Impl"
    // InternalEssentialOCL.g:11870:1: rule__TypeParameterCS__Group_1_2__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) ;
    public final void rule__TypeParameterCS__Group_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11874:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) )
            // InternalEssentialOCL.g:11875:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            {
            // InternalEssentialOCL.g:11875:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            // InternalEssentialOCL.g:11876:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1());
            }
            // InternalEssentialOCL.g:11877:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            // InternalEssentialOCL.g:11877:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group__0"
    // InternalEssentialOCL.g:11891:1: rule__TypedTypeRefCS__Group__0 : rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 ;
    public final void rule__TypedTypeRefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11895:1: ( rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 )
            // InternalEssentialOCL.g:11896:2: rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TypedTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__0"


    // $ANTLR start "rule__TypedTypeRefCS__Group__0__Impl"
    // InternalEssentialOCL.g:11903:1: rule__TypedTypeRefCS__Group__0__Impl : ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypedTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11907:1: ( ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEssentialOCL.g:11908:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEssentialOCL.g:11908:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            // InternalEssentialOCL.g:11909:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalEssentialOCL.g:11910:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            // InternalEssentialOCL.g:11910:2: rule__TypedTypeRefCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__0__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group__1"
    // InternalEssentialOCL.g:11920:1: rule__TypedTypeRefCS__Group__1 : rule__TypedTypeRefCS__Group__1__Impl ;
    public final void rule__TypedTypeRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11924:1: ( rule__TypedTypeRefCS__Group__1__Impl )
            // InternalEssentialOCL.g:11925:2: rule__TypedTypeRefCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__1"


    // $ANTLR start "rule__TypedTypeRefCS__Group__1__Impl"
    // InternalEssentialOCL.g:11931:1: rule__TypedTypeRefCS__Group__1__Impl : ( ( rule__TypedTypeRefCS__Group_1__0 )? ) ;
    public final void rule__TypedTypeRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11935:1: ( ( ( rule__TypedTypeRefCS__Group_1__0 )? ) )
            // InternalEssentialOCL.g:11936:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            {
            // InternalEssentialOCL.g:11936:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            // InternalEssentialOCL.g:11937:1: ( rule__TypedTypeRefCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup_1());
            }
            // InternalEssentialOCL.g:11938:1: ( rule__TypedTypeRefCS__Group_1__0 )?
            int alt97=2;
            int LA97_0 = input.LA(1);

            if ( (LA97_0==59) ) {
                alt97=1;
            }
            switch (alt97) {
                case 1 :
                    // InternalEssentialOCL.g:11938:2: rule__TypedTypeRefCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypedTypeRefCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__0"
    // InternalEssentialOCL.g:11952:1: rule__TypedTypeRefCS__Group_1__0 : rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 ;
    public final void rule__TypedTypeRefCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11956:1: ( rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 )
            // InternalEssentialOCL.g:11957:2: rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__TypedTypeRefCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__0"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__0__Impl"
    // InternalEssentialOCL.g:11964:1: rule__TypedTypeRefCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TypedTypeRefCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11968:1: ( ( '(' ) )
            // InternalEssentialOCL.g:11969:1: ( '(' )
            {
            // InternalEssentialOCL.g:11969:1: ( '(' )
            // InternalEssentialOCL.g:11970:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__1"
    // InternalEssentialOCL.g:11983:1: rule__TypedTypeRefCS__Group_1__1 : rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 ;
    public final void rule__TypedTypeRefCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11987:1: ( rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 )
            // InternalEssentialOCL.g:11988:2: rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__TypedTypeRefCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__1"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__1__Impl"
    // InternalEssentialOCL.g:11995:1: rule__TypedTypeRefCS__Group_1__1__Impl : ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) ;
    public final void rule__TypedTypeRefCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:11999:1: ( ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) )
            // InternalEssentialOCL.g:12000:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            {
            // InternalEssentialOCL.g:12000:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            // InternalEssentialOCL.g:12001:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1());
            }
            // InternalEssentialOCL.g:12002:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            // InternalEssentialOCL.g:12002:2: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__OwnedBindingAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__2"
    // InternalEssentialOCL.g:12012:1: rule__TypedTypeRefCS__Group_1__2 : rule__TypedTypeRefCS__Group_1__2__Impl ;
    public final void rule__TypedTypeRefCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12016:1: ( rule__TypedTypeRefCS__Group_1__2__Impl )
            // InternalEssentialOCL.g:12017:2: rule__TypedTypeRefCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__2"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__2__Impl"
    // InternalEssentialOCL.g:12023:1: rule__TypedTypeRefCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TypedTypeRefCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12027:1: ( ( ')' ) )
            // InternalEssentialOCL.g:12028:1: ( ')' )
            {
            // InternalEssentialOCL.g:12028:1: ( ')' )
            // InternalEssentialOCL.g:12029:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__2__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__0"
    // InternalEssentialOCL.g:12048:1: rule__WildcardTypeRefCS__Group__0 : rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 ;
    public final void rule__WildcardTypeRefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12052:1: ( rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 )
            // InternalEssentialOCL.g:12053:2: rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__WildcardTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__0"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__0__Impl"
    // InternalEssentialOCL.g:12060:1: rule__WildcardTypeRefCS__Group__0__Impl : ( () ) ;
    public final void rule__WildcardTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12064:1: ( ( () ) )
            // InternalEssentialOCL.g:12065:1: ( () )
            {
            // InternalEssentialOCL.g:12065:1: ( () )
            // InternalEssentialOCL.g:12066:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0());
            }
            // InternalEssentialOCL.g:12067:1: ()
            // InternalEssentialOCL.g:12069:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__0__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__1"
    // InternalEssentialOCL.g:12079:1: rule__WildcardTypeRefCS__Group__1 : rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 ;
    public final void rule__WildcardTypeRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12083:1: ( rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 )
            // InternalEssentialOCL.g:12084:2: rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__WildcardTypeRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__1"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__1__Impl"
    // InternalEssentialOCL.g:12091:1: rule__WildcardTypeRefCS__Group__1__Impl : ( '?' ) ;
    public final void rule__WildcardTypeRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12095:1: ( ( '?' ) )
            // InternalEssentialOCL.g:12096:1: ( '?' )
            {
            // InternalEssentialOCL.g:12096:1: ( '?' )
            // InternalEssentialOCL.g:12097:1: '?'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1());
            }
            match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__1__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__2"
    // InternalEssentialOCL.g:12110:1: rule__WildcardTypeRefCS__Group__2 : rule__WildcardTypeRefCS__Group__2__Impl ;
    public final void rule__WildcardTypeRefCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12114:1: ( rule__WildcardTypeRefCS__Group__2__Impl )
            // InternalEssentialOCL.g:12115:2: rule__WildcardTypeRefCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__2"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__2__Impl"
    // InternalEssentialOCL.g:12121:1: rule__WildcardTypeRefCS__Group__2__Impl : ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) ;
    public final void rule__WildcardTypeRefCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12125:1: ( ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) )
            // InternalEssentialOCL.g:12126:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            {
            // InternalEssentialOCL.g:12126:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            // InternalEssentialOCL.g:12127:1: ( rule__WildcardTypeRefCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2());
            }
            // InternalEssentialOCL.g:12128:1: ( rule__WildcardTypeRefCS__Group_2__0 )?
            int alt98=2;
            int LA98_0 = input.LA(1);

            if ( (LA98_0==82) ) {
                alt98=1;
            }
            switch (alt98) {
                case 1 :
                    // InternalEssentialOCL.g:12128:2: rule__WildcardTypeRefCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__WildcardTypeRefCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__2__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0"
    // InternalEssentialOCL.g:12144:1: rule__WildcardTypeRefCS__Group_2__0 : rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 ;
    public final void rule__WildcardTypeRefCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12148:1: ( rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 )
            // InternalEssentialOCL.g:12149:2: rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__WildcardTypeRefCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0__Impl"
    // InternalEssentialOCL.g:12156:1: rule__WildcardTypeRefCS__Group_2__0__Impl : ( 'extends' ) ;
    public final void rule__WildcardTypeRefCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12160:1: ( ( 'extends' ) )
            // InternalEssentialOCL.g:12161:1: ( 'extends' )
            {
            // InternalEssentialOCL.g:12161:1: ( 'extends' )
            // InternalEssentialOCL.g:12162:1: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0());
            }
            match(input,82,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1"
    // InternalEssentialOCL.g:12175:1: rule__WildcardTypeRefCS__Group_2__1 : rule__WildcardTypeRefCS__Group_2__1__Impl ;
    public final void rule__WildcardTypeRefCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12179:1: ( rule__WildcardTypeRefCS__Group_2__1__Impl )
            // InternalEssentialOCL.g:12180:2: rule__WildcardTypeRefCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__1"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1__Impl"
    // InternalEssentialOCL.g:12186:1: rule__WildcardTypeRefCS__Group_2__1__Impl : ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) ;
    public final void rule__WildcardTypeRefCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12190:1: ( ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) )
            // InternalEssentialOCL.g:12191:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            {
            // InternalEssentialOCL.g:12191:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            // InternalEssentialOCL.g:12192:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1());
            }
            // InternalEssentialOCL.g:12193:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            // InternalEssentialOCL.g:12193:2: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__1__Impl"


    // $ANTLR start "rule__Model__OwnedExpressionAssignment"
    // InternalEssentialOCL.g:12208:1: rule__Model__OwnedExpressionAssignment : ( ruleExpCS ) ;
    public final void rule__Model__OwnedExpressionAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12212:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12213:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12213:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12214:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelAccess().getOwnedExpressionExpCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getModelAccess().getOwnedExpressionExpCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__Model__OwnedExpressionAssignment"


    // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_0"
    // InternalEssentialOCL.g:12225:1: rule__URIFirstPathElementCS__ReferredElementAssignment_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12229:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEssentialOCL.g:12230:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalEssentialOCL.g:12230:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:12231:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0());
            }
            // InternalEssentialOCL.g:12232:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:12233:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_0"


    // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1"
    // InternalEssentialOCL.g:12244:1: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 : ( ( ruleURI ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12248:1: ( ( ( ruleURI ) ) )
            // InternalEssentialOCL.g:12249:1: ( ( ruleURI ) )
            {
            // InternalEssentialOCL.g:12249:1: ( ( ruleURI ) )
            // InternalEssentialOCL.g:12250:1: ( ruleURI )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0());
            }
            // InternalEssentialOCL.g:12251:1: ( ruleURI )
            // InternalEssentialOCL.g:12252:1: ruleURI
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleURI();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1"


    // $ANTLR start "rule__PrimitiveTypeCS__NameAssignment"
    // InternalEssentialOCL.g:12264:1: rule__PrimitiveTypeCS__NameAssignment : ( rulePrimitiveTypeIdentifier ) ;
    public final void rule__PrimitiveTypeCS__NameAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12268:1: ( ( rulePrimitiveTypeIdentifier ) )
            // InternalEssentialOCL.g:12269:1: ( rulePrimitiveTypeIdentifier )
            {
            // InternalEssentialOCL.g:12269:1: ( rulePrimitiveTypeIdentifier )
            // InternalEssentialOCL.g:12270:1: rulePrimitiveTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrimitiveTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveTypeCS__NameAssignment"


    // $ANTLR start "rule__CollectionTypeCS__NameAssignment_0"
    // InternalEssentialOCL.g:12279:1: rule__CollectionTypeCS__NameAssignment_0 : ( ruleCollectionTypeIdentifier ) ;
    public final void rule__CollectionTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12283:1: ( ( ruleCollectionTypeIdentifier ) )
            // InternalEssentialOCL.g:12284:1: ( ruleCollectionTypeIdentifier )
            {
            // InternalEssentialOCL.g:12284:1: ( ruleCollectionTypeIdentifier )
            // InternalEssentialOCL.g:12285:1: ruleCollectionTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__NameAssignment_0"


    // $ANTLR start "rule__CollectionTypeCS__OwnedTypeAssignment_1_1"
    // InternalEssentialOCL.g:12294:1: rule__CollectionTypeCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpWithoutMultiplicityCS ) ;
    public final void rule__CollectionTypeCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12298:1: ( ( ruleTypeExpWithoutMultiplicityCS ) )
            // InternalEssentialOCL.g:12299:1: ( ruleTypeExpWithoutMultiplicityCS )
            {
            // InternalEssentialOCL.g:12299:1: ( ruleTypeExpWithoutMultiplicityCS )
            // InternalEssentialOCL.g:12300:1: ruleTypeExpWithoutMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpWithoutMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2"
    // InternalEssentialOCL.g:12309:1: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 : ( ruleMultiplicityCS ) ;
    public final void rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12313:1: ( ( ruleMultiplicityCS ) )
            // InternalEssentialOCL.g:12314:1: ( ruleMultiplicityCS )
            {
            // InternalEssentialOCL.g:12314:1: ( ruleMultiplicityCS )
            // InternalEssentialOCL.g:12315:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2"


    // $ANTLR start "rule__MapTypeCS__NameAssignment_0"
    // InternalEssentialOCL.g:12324:1: rule__MapTypeCS__NameAssignment_0 : ( ( 'Map' ) ) ;
    public final void rule__MapTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12328:1: ( ( ( 'Map' ) ) )
            // InternalEssentialOCL.g:12329:1: ( ( 'Map' ) )
            {
            // InternalEssentialOCL.g:12329:1: ( ( 'Map' ) )
            // InternalEssentialOCL.g:12330:1: ( 'Map' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }
            // InternalEssentialOCL.g:12331:1: ( 'Map' )
            // InternalEssentialOCL.g:12332:1: 'Map'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }
            match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__NameAssignment_0"


    // $ANTLR start "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1"
    // InternalEssentialOCL.g:12347:1: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedKeyTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12351:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:12352:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:12352:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:12353:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1"


    // $ANTLR start "rule__MapTypeCS__OwnedValueTypeAssignment_1_3"
    // InternalEssentialOCL.g:12362:1: rule__MapTypeCS__OwnedValueTypeAssignment_1_3 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedValueTypeAssignment_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12366:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:12367:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:12367:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:12368:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__OwnedValueTypeAssignment_1_3"


    // $ANTLR start "rule__TupleTypeCS__NameAssignment_0"
    // InternalEssentialOCL.g:12377:1: rule__TupleTypeCS__NameAssignment_0 : ( ( 'Tuple' ) ) ;
    public final void rule__TupleTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12381:1: ( ( ( 'Tuple' ) ) )
            // InternalEssentialOCL.g:12382:1: ( ( 'Tuple' ) )
            {
            // InternalEssentialOCL.g:12382:1: ( ( 'Tuple' ) )
            // InternalEssentialOCL.g:12383:1: ( 'Tuple' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }
            // InternalEssentialOCL.g:12384:1: ( 'Tuple' )
            // InternalEssentialOCL.g:12385:1: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }
            match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__NameAssignment_0"


    // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0"
    // InternalEssentialOCL.g:12400:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 : ( ruleTuplePartCS ) ;
    public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12404:1: ( ( ruleTuplePartCS ) )
            // InternalEssentialOCL.g:12405:1: ( ruleTuplePartCS )
            {
            // InternalEssentialOCL.g:12405:1: ( ruleTuplePartCS )
            // InternalEssentialOCL.g:12406:1: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTuplePartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0"


    // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1"
    // InternalEssentialOCL.g:12415:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 : ( ruleTuplePartCS ) ;
    public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12419:1: ( ( ruleTuplePartCS ) )
            // InternalEssentialOCL.g:12420:1: ( ruleTuplePartCS )
            {
            // InternalEssentialOCL.g:12420:1: ( ruleTuplePartCS )
            // InternalEssentialOCL.g:12421:1: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTuplePartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1"


    // $ANTLR start "rule__TuplePartCS__NameAssignment_0"
    // InternalEssentialOCL.g:12430:1: rule__TuplePartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TuplePartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12434:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:12435:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:12435:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:12436:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__NameAssignment_0"


    // $ANTLR start "rule__TuplePartCS__OwnedTypeAssignment_2"
    // InternalEssentialOCL.g:12445:1: rule__TuplePartCS__OwnedTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__TuplePartCS__OwnedTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12449:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:12450:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:12450:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:12451:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__OwnedTypeAssignment_2"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0"
    // InternalEssentialOCL.g:12460:1: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12464:1: ( ( ruleCollectionTypeCS ) )
            // InternalEssentialOCL.g:12465:1: ( ruleCollectionTypeCS )
            {
            // InternalEssentialOCL.g:12465:1: ( ruleCollectionTypeCS )
            // InternalEssentialOCL.g:12466:1: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0"
    // InternalEssentialOCL.g:12475:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12479:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalEssentialOCL.g:12480:1: ( ruleCollectionLiteralPartCS )
            {
            // InternalEssentialOCL.g:12480:1: ( ruleCollectionLiteralPartCS )
            // InternalEssentialOCL.g:12481:1: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1"
    // InternalEssentialOCL.g:12490:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12494:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalEssentialOCL.g:12495:1: ( ruleCollectionLiteralPartCS )
            {
            // InternalEssentialOCL.g:12495:1: ( ruleCollectionLiteralPartCS )
            // InternalEssentialOCL.g:12496:1: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0"
    // InternalEssentialOCL.g:12505:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12509:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12510:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12510:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12511:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1"
    // InternalEssentialOCL.g:12520:1: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12524:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12525:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12525:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12526:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1"
    // InternalEssentialOCL.g:12535:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12539:1: ( ( rulePatternExpCS ) )
            // InternalEssentialOCL.g:12540:1: ( rulePatternExpCS )
            {
            // InternalEssentialOCL.g:12540:1: ( rulePatternExpCS )
            // InternalEssentialOCL.g:12541:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1"


    // $ANTLR start "rule__CollectionPatternCS__OwnedTypeAssignment_0"
    // InternalEssentialOCL.g:12550:1: rule__CollectionPatternCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionPatternCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12554:1: ( ( ruleCollectionTypeCS ) )
            // InternalEssentialOCL.g:12555:1: ( ruleCollectionTypeCS )
            {
            // InternalEssentialOCL.g:12555:1: ( ruleCollectionTypeCS )
            // InternalEssentialOCL.g:12556:1: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_0"
    // InternalEssentialOCL.g:12565:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_0 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12569:1: ( ( rulePatternExpCS ) )
            // InternalEssentialOCL.g:12570:1: ( rulePatternExpCS )
            {
            // InternalEssentialOCL.g:12570:1: ( rulePatternExpCS )
            // InternalEssentialOCL.g:12571:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1"
    // InternalEssentialOCL.g:12580:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12584:1: ( ( rulePatternExpCS ) )
            // InternalEssentialOCL.g:12585:1: ( rulePatternExpCS )
            {
            // InternalEssentialOCL.g:12585:1: ( rulePatternExpCS )
            // InternalEssentialOCL.g:12586:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1"
    // InternalEssentialOCL.g:12595:1: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 : ( ruleIdentifier ) ;
    public final void rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12599:1: ( ( ruleIdentifier ) )
            // InternalEssentialOCL.g:12600:1: ( ruleIdentifier )
            {
            // InternalEssentialOCL.g:12600:1: ( ruleIdentifier )
            // InternalEssentialOCL.g:12601:1: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1"


    // $ANTLR start "rule__ShadowPartCS__ReferredPropertyAssignment_0_0"
    // InternalEssentialOCL.g:12610:1: rule__ShadowPartCS__ReferredPropertyAssignment_0_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__ShadowPartCS__ReferredPropertyAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12614:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEssentialOCL.g:12615:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalEssentialOCL.g:12615:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:12616:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0());
            }
            // InternalEssentialOCL.g:12617:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:12618:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__ReferredPropertyAssignment_0_0"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2"
    // InternalEssentialOCL.g:12629:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 : ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) ;
    public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12633:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) )
            // InternalEssentialOCL.g:12634:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) )
            {
            // InternalEssentialOCL.g:12634:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) )
            // InternalEssentialOCL.g:12635:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0());
            }
            // InternalEssentialOCL.g:12636:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 )
            // InternalEssentialOCL.g:12636:2: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_1"
    // InternalEssentialOCL.g:12645:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_1 : ( ruleStringLiteralExpCS ) ;
    public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12649:1: ( ( ruleStringLiteralExpCS ) )
            // InternalEssentialOCL.g:12650:1: ( ruleStringLiteralExpCS )
            {
            // InternalEssentialOCL.g:12650:1: ( ruleStringLiteralExpCS )
            // InternalEssentialOCL.g:12651:1: ruleStringLiteralExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleStringLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_1"


    // $ANTLR start "rule__PatternExpCS__PatternVariableNameAssignment_0"
    // InternalEssentialOCL.g:12660:1: rule__PatternExpCS__PatternVariableNameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__PatternExpCS__PatternVariableNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12664:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:12665:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:12665:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:12666:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__PatternVariableNameAssignment_0"


    // $ANTLR start "rule__PatternExpCS__OwnedPatternTypeAssignment_2"
    // InternalEssentialOCL.g:12675:1: rule__PatternExpCS__OwnedPatternTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__PatternExpCS__OwnedPatternTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12679:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:12680:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:12680:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:12681:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__OwnedPatternTypeAssignment_2"


    // $ANTLR start "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2"
    // InternalEssentialOCL.g:12690:1: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 : ( ruleExpCS ) ;
    public final void rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12694:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12695:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12695:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12696:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedTypeAssignment_0"
    // InternalEssentialOCL.g:12705:1: rule__MapLiteralExpCS__OwnedTypeAssignment_0 : ( ruleMapTypeCS ) ;
    public final void rule__MapLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12709:1: ( ( ruleMapTypeCS ) )
            // InternalEssentialOCL.g:12710:1: ( ruleMapTypeCS )
            {
            // InternalEssentialOCL.g:12710:1: ( ruleMapTypeCS )
            // InternalEssentialOCL.g:12711:1: ruleMapTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0"
    // InternalEssentialOCL.g:12720:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12724:1: ( ( ruleMapLiteralPartCS ) )
            // InternalEssentialOCL.g:12725:1: ( ruleMapLiteralPartCS )
            {
            // InternalEssentialOCL.g:12725:1: ( ruleMapLiteralPartCS )
            // InternalEssentialOCL.g:12726:1: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1"
    // InternalEssentialOCL.g:12735:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12739:1: ( ( ruleMapLiteralPartCS ) )
            // InternalEssentialOCL.g:12740:1: ( ruleMapLiteralPartCS )
            {
            // InternalEssentialOCL.g:12740:1: ( ruleMapLiteralPartCS )
            // InternalEssentialOCL.g:12741:1: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__MapLiteralPartCS__OwnedKeyAssignment_0"
    // InternalEssentialOCL.g:12750:1: rule__MapLiteralPartCS__OwnedKeyAssignment_0 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedKeyAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12754:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12755:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12755:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12756:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__OwnedKeyAssignment_0"


    // $ANTLR start "rule__MapLiteralPartCS__OwnedValueAssignment_2"
    // InternalEssentialOCL.g:12765:1: rule__MapLiteralPartCS__OwnedValueAssignment_2 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedValueAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12769:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12770:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12770:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12771:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__OwnedValueAssignment_2"


    // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_2"
    // InternalEssentialOCL.g:12780:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_2 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12784:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalEssentialOCL.g:12785:1: ( ruleTupleLiteralPartCS )
            {
            // InternalEssentialOCL.g:12785:1: ( ruleTupleLiteralPartCS )
            // InternalEssentialOCL.g:12786:1: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTupleLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_2"


    // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1"
    // InternalEssentialOCL.g:12795:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12799:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalEssentialOCL.g:12800:1: ( ruleTupleLiteralPartCS )
            {
            // InternalEssentialOCL.g:12800:1: ( ruleTupleLiteralPartCS )
            // InternalEssentialOCL.g:12801:1: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTupleLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1"


    // $ANTLR start "rule__TupleLiteralPartCS__NameAssignment_0"
    // InternalEssentialOCL.g:12810:1: rule__TupleLiteralPartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TupleLiteralPartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12814:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:12815:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:12815:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:12816:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__NameAssignment_0"


    // $ANTLR start "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1"
    // InternalEssentialOCL.g:12825:1: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12829:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:12830:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:12830:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:12831:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3"
    // InternalEssentialOCL.g:12840:1: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12844:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12845:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12845:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12846:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3"


    // $ANTLR start "rule__NumberLiteralExpCS__SymbolAssignment"
    // InternalEssentialOCL.g:12855:1: rule__NumberLiteralExpCS__SymbolAssignment : ( ruleNUMBER_LITERAL ) ;
    public final void rule__NumberLiteralExpCS__SymbolAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12859:1: ( ( ruleNUMBER_LITERAL ) )
            // InternalEssentialOCL.g:12860:1: ( ruleNUMBER_LITERAL )
            {
            // InternalEssentialOCL.g:12860:1: ( ruleNUMBER_LITERAL )
            // InternalEssentialOCL.g:12861:1: ruleNUMBER_LITERAL
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNUMBER_LITERAL();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NumberLiteralExpCS__SymbolAssignment"


    // $ANTLR start "rule__StringLiteralExpCS__SegmentsAssignment"
    // InternalEssentialOCL.g:12870:1: rule__StringLiteralExpCS__SegmentsAssignment : ( ruleStringLiteral ) ;
    public final void rule__StringLiteralExpCS__SegmentsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12874:1: ( ( ruleStringLiteral ) )
            // InternalEssentialOCL.g:12875:1: ( ruleStringLiteral )
            {
            // InternalEssentialOCL.g:12875:1: ( ruleStringLiteral )
            // InternalEssentialOCL.g:12876:1: ruleStringLiteral
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleStringLiteral();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StringLiteralExpCS__SegmentsAssignment"


    // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_0"
    // InternalEssentialOCL.g:12885:1: rule__BooleanLiteralExpCS__SymbolAssignment_0 : ( ( 'true' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12889:1: ( ( ( 'true' ) ) )
            // InternalEssentialOCL.g:12890:1: ( ( 'true' ) )
            {
            // InternalEssentialOCL.g:12890:1: ( ( 'true' ) )
            // InternalEssentialOCL.g:12891:1: ( 'true' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }
            // InternalEssentialOCL.g:12892:1: ( 'true' )
            // InternalEssentialOCL.g:12893:1: 'true'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }
            match(input,84,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_0"


    // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_1"
    // InternalEssentialOCL.g:12908:1: rule__BooleanLiteralExpCS__SymbolAssignment_1 : ( ( 'false' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12912:1: ( ( ( 'false' ) ) )
            // InternalEssentialOCL.g:12913:1: ( ( 'false' ) )
            {
            // InternalEssentialOCL.g:12913:1: ( ( 'false' ) )
            // InternalEssentialOCL.g:12914:1: ( 'false' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }
            // InternalEssentialOCL.g:12915:1: ( 'false' )
            // InternalEssentialOCL.g:12916:1: 'false'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }
            match(input,85,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_1"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1"
    // InternalEssentialOCL.g:12931:1: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12935:1: ( ( ruleMultiplicityCS ) )
            // InternalEssentialOCL.g:12936:1: ( ruleMultiplicityCS )
            {
            // InternalEssentialOCL.g:12936:1: ( ruleMultiplicityCS )
            // InternalEssentialOCL.g:12937:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1"


    // $ANTLR start "rule__TypeLiteralExpCS__OwnedTypeAssignment"
    // InternalEssentialOCL.g:12946:1: rule__TypeLiteralExpCS__OwnedTypeAssignment : ( ruleTypeLiteralWithMultiplicityCS ) ;
    public final void rule__TypeLiteralExpCS__OwnedTypeAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12950:1: ( ( ruleTypeLiteralWithMultiplicityCS ) )
            // InternalEssentialOCL.g:12951:1: ( ruleTypeLiteralWithMultiplicityCS )
            {
            // InternalEssentialOCL.g:12951:1: ( ruleTypeLiteralWithMultiplicityCS )
            // InternalEssentialOCL.g:12952:1: ruleTypeLiteralWithMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeLiteralWithMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralExpCS__OwnedTypeAssignment"


    // $ANTLR start "rule__TypeNameExpCS__OwnedPathNameAssignment_0"
    // InternalEssentialOCL.g:12961:1: rule__TypeNameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypeNameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12965:1: ( ( rulePathNameCS ) )
            // InternalEssentialOCL.g:12966:1: ( rulePathNameCS )
            {
            // InternalEssentialOCL.g:12966:1: ( rulePathNameCS )
            // InternalEssentialOCL.g:12967:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0"
    // InternalEssentialOCL.g:12976:1: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12980:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalEssentialOCL.g:12981:1: ( ruleCurlyBracketedClauseCS )
            {
            // InternalEssentialOCL.g:12981:1: ( ruleCurlyBracketedClauseCS )
            // InternalEssentialOCL.g:12982:1: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCurlyBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0"


    // $ANTLR start "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1"
    // InternalEssentialOCL.g:12991:1: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 : ( ruleExpCS ) ;
    public final void rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:12995:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:12996:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:12996:1: ( ruleExpCS )
            // InternalEssentialOCL.g:12997:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1"


    // $ANTLR start "rule__TypeExpCS__OwnedMultiplicityAssignment_1"
    // InternalEssentialOCL.g:13006:1: rule__TypeExpCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeExpCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13010:1: ( ( ruleMultiplicityCS ) )
            // InternalEssentialOCL.g:13011:1: ( ruleMultiplicityCS )
            {
            // InternalEssentialOCL.g:13011:1: ( ruleMultiplicityCS )
            // InternalEssentialOCL.g:13012:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__OwnedMultiplicityAssignment_1"


    // $ANTLR start "rule__ExpCS__NameAssignment_0_1_1"
    // InternalEssentialOCL.g:13021:1: rule__ExpCS__NameAssignment_0_1_1 : ( ruleBinaryOperatorName ) ;
    public final void rule__ExpCS__NameAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13025:1: ( ( ruleBinaryOperatorName ) )
            // InternalEssentialOCL.g:13026:1: ( ruleBinaryOperatorName )
            {
            // InternalEssentialOCL.g:13026:1: ( ruleBinaryOperatorName )
            // InternalEssentialOCL.g:13027:1: ruleBinaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleBinaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__NameAssignment_0_1_1"


    // $ANTLR start "rule__ExpCS__OwnedRightAssignment_0_1_2"
    // InternalEssentialOCL.g:13036:1: rule__ExpCS__OwnedRightAssignment_0_1_2 : ( ruleExpCS ) ;
    public final void rule__ExpCS__OwnedRightAssignment_0_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13040:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13041:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13041:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13042:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__OwnedRightAssignment_0_1_2"


    // $ANTLR start "rule__PrefixedLetExpCS__NameAssignment_0_1"
    // InternalEssentialOCL.g:13051:1: rule__PrefixedLetExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedLetExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13055:1: ( ( ruleUnaryOperatorName ) )
            // InternalEssentialOCL.g:13056:1: ( ruleUnaryOperatorName )
            {
            // InternalEssentialOCL.g:13056:1: ( ruleUnaryOperatorName )
            // InternalEssentialOCL.g:13057:1: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__NameAssignment_0_1"


    // $ANTLR start "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2"
    // InternalEssentialOCL.g:13066:1: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedLetExpCS ) ;
    public final void rule__PrefixedLetExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13070:1: ( ( rulePrefixedLetExpCS ) )
            // InternalEssentialOCL.g:13071:1: ( rulePrefixedLetExpCS )
            {
            // InternalEssentialOCL.g:13071:1: ( rulePrefixedLetExpCS )
            // InternalEssentialOCL.g:13072:1: rulePrefixedLetExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedLetExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__NameAssignment_0_1"
    // InternalEssentialOCL.g:13081:1: rule__PrefixedPrimaryExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedPrimaryExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13085:1: ( ( ruleUnaryOperatorName ) )
            // InternalEssentialOCL.g:13086:1: ( ruleUnaryOperatorName )
            {
            // InternalEssentialOCL.g:13086:1: ( ruleUnaryOperatorName )
            // InternalEssentialOCL.g:13087:1: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__NameAssignment_0_1"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2"
    // InternalEssentialOCL.g:13096:1: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13100:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalEssentialOCL.g:13101:1: ( rulePrefixedPrimaryExpCS )
            {
            // InternalEssentialOCL.g:13101:1: ( rulePrefixedPrimaryExpCS )
            // InternalEssentialOCL.g:13102:1: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedPrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2"


    // $ANTLR start "rule__NameExpCS__OwnedPathNameAssignment_0"
    // InternalEssentialOCL.g:13111:1: rule__NameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__NameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13115:1: ( ( rulePathNameCS ) )
            // InternalEssentialOCL.g:13116:1: ( rulePathNameCS )
            {
            // InternalEssentialOCL.g:13116:1: ( rulePathNameCS )
            // InternalEssentialOCL.g:13117:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1"
    // InternalEssentialOCL.g:13126:1: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 : ( ruleSquareBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13130:1: ( ( ruleSquareBracketedClauseCS ) )
            // InternalEssentialOCL.g:13131:1: ( ruleSquareBracketedClauseCS )
            {
            // InternalEssentialOCL.g:13131:1: ( ruleSquareBracketedClauseCS )
            // InternalEssentialOCL.g:13132:1: ruleSquareBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSquareBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1"


    // $ANTLR start "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2"
    // InternalEssentialOCL.g:13141:1: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13145:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalEssentialOCL.g:13146:1: ( ruleRoundBracketedClauseCS )
            {
            // InternalEssentialOCL.g:13146:1: ( ruleRoundBracketedClauseCS )
            // InternalEssentialOCL.g:13147:1: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleRoundBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2"


    // $ANTLR start "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3"
    // InternalEssentialOCL.g:13156:1: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13160:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalEssentialOCL.g:13161:1: ( ruleCurlyBracketedClauseCS )
            {
            // InternalEssentialOCL.g:13161:1: ( ruleCurlyBracketedClauseCS )
            // InternalEssentialOCL.g:13162:1: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCurlyBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3"


    // $ANTLR start "rule__NameExpCS__IsPreAssignment_4_0"
    // InternalEssentialOCL.g:13171:1: rule__NameExpCS__IsPreAssignment_4_0 : ( ( '@' ) ) ;
    public final void rule__NameExpCS__IsPreAssignment_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13175:1: ( ( ( '@' ) ) )
            // InternalEssentialOCL.g:13176:1: ( ( '@' ) )
            {
            // InternalEssentialOCL.g:13176:1: ( ( '@' ) )
            // InternalEssentialOCL.g:13177:1: ( '@' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }
            // InternalEssentialOCL.g:13178:1: ( '@' )
            // InternalEssentialOCL.g:13179:1: '@'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }
            match(input,86,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__IsPreAssignment_4_0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0"
    // InternalEssentialOCL.g:13194:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13198:1: ( ( ruleShadowPartCS ) )
            // InternalEssentialOCL.g:13199:1: ( ruleShadowPartCS )
            {
            // InternalEssentialOCL.g:13199:1: ( ruleShadowPartCS )
            // InternalEssentialOCL.g:13200:1: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleShadowPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1"
    // InternalEssentialOCL.g:13209:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13213:1: ( ( ruleShadowPartCS ) )
            // InternalEssentialOCL.g:13214:1: ( ruleShadowPartCS )
            {
            // InternalEssentialOCL.g:13214:1: ( ruleShadowPartCS )
            // InternalEssentialOCL.g:13215:1: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleShadowPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0"
    // InternalEssentialOCL.g:13224:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 : ( ruleNavigatingArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13228:1: ( ( ruleNavigatingArgCS ) )
            // InternalEssentialOCL.g:13229:1: ( ruleNavigatingArgCS )
            {
            // InternalEssentialOCL.g:13229:1: ( ruleNavigatingArgCS )
            // InternalEssentialOCL.g:13230:1: ruleNavigatingArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1"
    // InternalEssentialOCL.g:13239:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13243:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) )
            // InternalEssentialOCL.g:13244:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) )
            {
            // InternalEssentialOCL.g:13244:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) )
            // InternalEssentialOCL.g:13245:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0());
            }
            // InternalEssentialOCL.g:13246:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 )
            // InternalEssentialOCL.g:13246:2: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1"


    // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1"
    // InternalEssentialOCL.g:13255:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13259:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13260:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13260:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13261:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1"


    // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1"
    // InternalEssentialOCL.g:13270:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13274:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13275:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13275:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13276:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0"
    // InternalEssentialOCL.g:13285:1: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13289:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEssentialOCL.g:13290:1: ( ruleNavigatingArgExpCS )
            {
            // InternalEssentialOCL.g:13290:1: ( ruleNavigatingArgExpCS )
            // InternalEssentialOCL.g:13291:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1"
    // InternalEssentialOCL.g:13300:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13304:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13305:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13305:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13306:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1"
    // InternalEssentialOCL.g:13315:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13319:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13320:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13320:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13321:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1"
    // InternalEssentialOCL.g:13330:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13334:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13335:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13335:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13336:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1"
    // InternalEssentialOCL.g:13345:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13349:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13350:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13350:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13351:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1"
    // InternalEssentialOCL.g:13360:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13364:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13365:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13365:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13366:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1"
    // InternalEssentialOCL.g:13375:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13379:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13380:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13380:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13381:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1"
    // InternalEssentialOCL.g:13390:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13394:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13395:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13395:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13396:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3"
    // InternalEssentialOCL.g:13405:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13409:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13410:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13410:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13411:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_1_1"
    // InternalEssentialOCL.g:13420:1: rule__NavigatingArgCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13424:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13425:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13425:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13426:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__NavigatingBarArgCS__PrefixAssignment_0"
    // InternalEssentialOCL.g:13435:1: rule__NavigatingBarArgCS__PrefixAssignment_0 : ( ( '|' ) ) ;
    public final void rule__NavigatingBarArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13439:1: ( ( ( '|' ) ) )
            // InternalEssentialOCL.g:13440:1: ( ( '|' ) )
            {
            // InternalEssentialOCL.g:13440:1: ( ( '|' ) )
            // InternalEssentialOCL.g:13441:1: ( '|' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }
            // InternalEssentialOCL.g:13442:1: ( '|' )
            // InternalEssentialOCL.g:13443:1: '|'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }
            match(input,87,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1"
    // InternalEssentialOCL.g:13458:1: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13462:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEssentialOCL.g:13463:1: ( ruleNavigatingArgExpCS )
            {
            // InternalEssentialOCL.g:13463:1: ( ruleNavigatingArgExpCS )
            // InternalEssentialOCL.g:13464:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1"
    // InternalEssentialOCL.g:13473:1: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13477:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13478:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13478:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13479:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1"
    // InternalEssentialOCL.g:13488:1: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13492:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13493:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13493:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13494:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__PrefixAssignment_0"
    // InternalEssentialOCL.g:13503:1: rule__NavigatingCommaArgCS__PrefixAssignment_0 : ( ( ',' ) ) ;
    public final void rule__NavigatingCommaArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13507:1: ( ( ( ',' ) ) )
            // InternalEssentialOCL.g:13508:1: ( ( ',' ) )
            {
            // InternalEssentialOCL.g:13508:1: ( ( ',' ) )
            // InternalEssentialOCL.g:13509:1: ( ',' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }
            // InternalEssentialOCL.g:13510:1: ( ',' )
            // InternalEssentialOCL.g:13511:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1"
    // InternalEssentialOCL.g:13526:1: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13530:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEssentialOCL.g:13531:1: ( ruleNavigatingArgExpCS )
            {
            // InternalEssentialOCL.g:13531:1: ( ruleNavigatingArgExpCS )
            // InternalEssentialOCL.g:13532:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1"
    // InternalEssentialOCL.g:13541:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13545:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13546:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13546:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13547:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1"
    // InternalEssentialOCL.g:13556:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13560:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13561:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13561:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13562:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1"
    // InternalEssentialOCL.g:13571:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13575:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13576:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13576:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13577:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1"
    // InternalEssentialOCL.g:13586:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13590:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13591:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13591:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13592:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1"
    // InternalEssentialOCL.g:13601:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13605:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13606:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13606:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13607:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1"
    // InternalEssentialOCL.g:13616:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13620:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13621:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13621:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13622:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1"
    // InternalEssentialOCL.g:13631:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13635:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalEssentialOCL.g:13636:1: ( ruleCoIteratorVariableCS )
            {
            // InternalEssentialOCL.g:13636:1: ( ruleCoIteratorVariableCS )
            // InternalEssentialOCL.g:13637:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3"
    // InternalEssentialOCL.g:13646:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13650:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13651:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13651:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13652:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3"


    // $ANTLR start "rule__NavigatingSemiArgCS__PrefixAssignment_0"
    // InternalEssentialOCL.g:13661:1: rule__NavigatingSemiArgCS__PrefixAssignment_0 : ( ( ';' ) ) ;
    public final void rule__NavigatingSemiArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13665:1: ( ( ( ';' ) ) )
            // InternalEssentialOCL.g:13666:1: ( ( ';' ) )
            {
            // InternalEssentialOCL.g:13666:1: ( ( ';' ) )
            // InternalEssentialOCL.g:13667:1: ( ';' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }
            // InternalEssentialOCL.g:13668:1: ( ';' )
            // InternalEssentialOCL.g:13669:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }
            match(input,88,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1"
    // InternalEssentialOCL.g:13684:1: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13688:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEssentialOCL.g:13689:1: ( ruleNavigatingArgExpCS )
            {
            // InternalEssentialOCL.g:13689:1: ( ruleNavigatingArgExpCS )
            // InternalEssentialOCL.g:13690:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1"
    // InternalEssentialOCL.g:13699:1: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13703:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13704:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13704:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13705:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1"
    // InternalEssentialOCL.g:13714:1: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13718:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13719:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13719:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13720:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1"


    // $ANTLR start "rule__CoIteratorVariableCS__NameAssignment_0"
    // InternalEssentialOCL.g:13729:1: rule__CoIteratorVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__CoIteratorVariableCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13733:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:13734:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:13734:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:13735:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__NameAssignment_0"


    // $ANTLR start "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1"
    // InternalEssentialOCL.g:13744:1: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13748:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13749:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13749:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13750:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__IfExpCS__OwnedConditionAssignment_1"
    // InternalEssentialOCL.g:13759:1: rule__IfExpCS__OwnedConditionAssignment_1 : ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) ;
    public final void rule__IfExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13763:1: ( ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) )
            // InternalEssentialOCL.g:13764:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            {
            // InternalEssentialOCL.g:13764:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            // InternalEssentialOCL.g:13765:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0());
            }
            // InternalEssentialOCL.g:13766:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            // InternalEssentialOCL.g:13766:2: rule__IfExpCS__OwnedConditionAlternatives_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedConditionAlternatives_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedConditionAssignment_1"


    // $ANTLR start "rule__IfExpCS__OwnedThenExpressionAssignment_3"
    // InternalEssentialOCL.g:13775:1: rule__IfExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13779:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13780:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13780:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13781:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedThenExpressionAssignment_3"


    // $ANTLR start "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4"
    // InternalEssentialOCL.g:13790:1: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 : ( ruleElseIfThenExpCS ) ;
    public final void rule__IfExpCS__OwnedIfThenExpressionsAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13794:1: ( ( ruleElseIfThenExpCS ) )
            // InternalEssentialOCL.g:13795:1: ( ruleElseIfThenExpCS )
            {
            // InternalEssentialOCL.g:13795:1: ( ruleElseIfThenExpCS )
            // InternalEssentialOCL.g:13796:1: ruleElseIfThenExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleElseIfThenExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4"


    // $ANTLR start "rule__IfExpCS__OwnedElseExpressionAssignment_6"
    // InternalEssentialOCL.g:13805:1: rule__IfExpCS__OwnedElseExpressionAssignment_6 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedElseExpressionAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13809:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13810:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13810:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13811:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedElseExpressionAssignment_6"


    // $ANTLR start "rule__ElseIfThenExpCS__OwnedConditionAssignment_1"
    // InternalEssentialOCL.g:13820:1: rule__ElseIfThenExpCS__OwnedConditionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13824:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13825:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13825:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13826:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__OwnedConditionAssignment_1"


    // $ANTLR start "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3"
    // InternalEssentialOCL.g:13835:1: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13839:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13840:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13840:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13841:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3"


    // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_1"
    // InternalEssentialOCL.g:13850:1: rule__LetExpCS__OwnedVariablesAssignment_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13854:1: ( ( ruleLetVariableCS ) )
            // InternalEssentialOCL.g:13855:1: ( ruleLetVariableCS )
            {
            // InternalEssentialOCL.g:13855:1: ( ruleLetVariableCS )
            // InternalEssentialOCL.g:13856:1: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLetVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_1"


    // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_2_1"
    // InternalEssentialOCL.g:13865:1: rule__LetExpCS__OwnedVariablesAssignment_2_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13869:1: ( ( ruleLetVariableCS ) )
            // InternalEssentialOCL.g:13870:1: ( ruleLetVariableCS )
            {
            // InternalEssentialOCL.g:13870:1: ( ruleLetVariableCS )
            // InternalEssentialOCL.g:13871:1: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLetVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_2_1"


    // $ANTLR start "rule__LetExpCS__OwnedInExpressionAssignment_4"
    // InternalEssentialOCL.g:13880:1: rule__LetExpCS__OwnedInExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetExpCS__OwnedInExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13884:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13885:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13885:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13886:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedInExpressionAssignment_4"


    // $ANTLR start "rule__LetVariableCS__NameAssignment_0"
    // InternalEssentialOCL.g:13895:1: rule__LetVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__LetVariableCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13899:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:13900:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:13900:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:13901:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__NameAssignment_0"


    // $ANTLR start "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1"
    // InternalEssentialOCL.g:13910:1: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13914:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalEssentialOCL.g:13915:1: ( ruleRoundBracketedClauseCS )
            {
            // InternalEssentialOCL.g:13915:1: ( ruleRoundBracketedClauseCS )
            // InternalEssentialOCL.g:13916:1: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleRoundBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1"


    // $ANTLR start "rule__LetVariableCS__OwnedTypeAssignment_2_1"
    // InternalEssentialOCL.g:13925:1: rule__LetVariableCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__LetVariableCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13929:1: ( ( ruleTypeExpCS ) )
            // InternalEssentialOCL.g:13930:1: ( ruleTypeExpCS )
            {
            // InternalEssentialOCL.g:13930:1: ( ruleTypeExpCS )
            // InternalEssentialOCL.g:13931:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__LetVariableCS__OwnedInitExpressionAssignment_4"
    // InternalEssentialOCL.g:13940:1: rule__LetVariableCS__OwnedInitExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetVariableCS__OwnedInitExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13944:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13945:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13945:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13946:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedInitExpressionAssignment_4"


    // $ANTLR start "rule__NestedExpCS__OwnedExpressionAssignment_1"
    // InternalEssentialOCL.g:13955:1: rule__NestedExpCS__OwnedExpressionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__NestedExpCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13959:1: ( ( ruleExpCS ) )
            // InternalEssentialOCL.g:13960:1: ( ruleExpCS )
            {
            // InternalEssentialOCL.g:13960:1: ( ruleExpCS )
            // InternalEssentialOCL.g:13961:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__OwnedExpressionAssignment_1"


    // $ANTLR start "rule__MultiplicityBoundsCS__LowerBoundAssignment_0"
    // InternalEssentialOCL.g:13970:1: rule__MultiplicityBoundsCS__LowerBoundAssignment_0 : ( ruleLOWER ) ;
    public final void rule__MultiplicityBoundsCS__LowerBoundAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13974:1: ( ( ruleLOWER ) )
            // InternalEssentialOCL.g:13975:1: ( ruleLOWER )
            {
            // InternalEssentialOCL.g:13975:1: ( ruleLOWER )
            // InternalEssentialOCL.g:13976:1: ruleLOWER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLOWER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__LowerBoundAssignment_0"


    // $ANTLR start "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1"
    // InternalEssentialOCL.g:13985:1: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 : ( ruleUPPER ) ;
    public final void rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:13989:1: ( ( ruleUPPER ) )
            // InternalEssentialOCL.g:13990:1: ( ruleUPPER )
            {
            // InternalEssentialOCL.g:13990:1: ( ruleUPPER )
            // InternalEssentialOCL.g:13991:1: ruleUPPER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUPPER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1"


    // $ANTLR start "rule__MultiplicityCS__IsNullFreeAssignment_2_1"
    // InternalEssentialOCL.g:14000:1: rule__MultiplicityCS__IsNullFreeAssignment_2_1 : ( ( '|1' ) ) ;
    public final void rule__MultiplicityCS__IsNullFreeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14004:1: ( ( ( '|1' ) ) )
            // InternalEssentialOCL.g:14005:1: ( ( '|1' ) )
            {
            // InternalEssentialOCL.g:14005:1: ( ( '|1' ) )
            // InternalEssentialOCL.g:14006:1: ( '|1' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }
            // InternalEssentialOCL.g:14007:1: ( '|1' )
            // InternalEssentialOCL.g:14008:1: '|1'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }
            match(input,89,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__IsNullFreeAssignment_2_1"


    // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAssignment"
    // InternalEssentialOCL.g:14023:1: rule__MultiplicityStringCS__StringBoundsAssignment : ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) ;
    public final void rule__MultiplicityStringCS__StringBoundsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14027:1: ( ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) )
            // InternalEssentialOCL.g:14028:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            {
            // InternalEssentialOCL.g:14028:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            // InternalEssentialOCL.g:14029:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0());
            }
            // InternalEssentialOCL.g:14030:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            // InternalEssentialOCL.g:14030:2: rule__MultiplicityStringCS__StringBoundsAlternatives_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityStringCS__StringBoundsAlternatives_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAssignment"


    // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_0"
    // InternalEssentialOCL.g:14039:1: rule__PathNameCS__OwnedPathElementsAssignment_0 : ( ruleFirstPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14043:1: ( ( ruleFirstPathElementCS ) )
            // InternalEssentialOCL.g:14044:1: ( ruleFirstPathElementCS )
            {
            // InternalEssentialOCL.g:14044:1: ( ruleFirstPathElementCS )
            // InternalEssentialOCL.g:14045:1: ruleFirstPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleFirstPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_0"


    // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_1_1"
    // InternalEssentialOCL.g:14054:1: rule__PathNameCS__OwnedPathElementsAssignment_1_1 : ( ruleNextPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14058:1: ( ( ruleNextPathElementCS ) )
            // InternalEssentialOCL.g:14059:1: ( ruleNextPathElementCS )
            {
            // InternalEssentialOCL.g:14059:1: ( ruleNextPathElementCS )
            // InternalEssentialOCL.g:14060:1: ruleNextPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNextPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_1_1"


    // $ANTLR start "rule__FirstPathElementCS__ReferredElementAssignment"
    // InternalEssentialOCL.g:14071:1: rule__FirstPathElementCS__ReferredElementAssignment : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__FirstPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14075:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEssentialOCL.g:14076:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalEssentialOCL.g:14076:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:14077:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }
            // InternalEssentialOCL.g:14078:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:14079:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FirstPathElementCS__ReferredElementAssignment"


    // $ANTLR start "rule__NextPathElementCS__ReferredElementAssignment"
    // InternalEssentialOCL.g:14090:1: rule__NextPathElementCS__ReferredElementAssignment : ( ( ruleUnreservedName ) ) ;
    public final void rule__NextPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14094:1: ( ( ( ruleUnreservedName ) ) )
            // InternalEssentialOCL.g:14095:1: ( ( ruleUnreservedName ) )
            {
            // InternalEssentialOCL.g:14095:1: ( ( ruleUnreservedName ) )
            // InternalEssentialOCL.g:14096:1: ( ruleUnreservedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }
            // InternalEssentialOCL.g:14097:1: ( ruleUnreservedName )
            // InternalEssentialOCL.g:14098:1: ruleUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnreservedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NextPathElementCS__ReferredElementAssignment"


    // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0"
    // InternalEssentialOCL.g:14109:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14113:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalEssentialOCL.g:14114:1: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalEssentialOCL.g:14114:1: ( ruleTemplateParameterSubstitutionCS )
            // InternalEssentialOCL.g:14115:1: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateParameterSubstitutionCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0"


    // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1"
    // InternalEssentialOCL.g:14124:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14128:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalEssentialOCL.g:14129:1: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalEssentialOCL.g:14129:1: ( ruleTemplateParameterSubstitutionCS )
            // InternalEssentialOCL.g:14130:1: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateParameterSubstitutionCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1"


    // $ANTLR start "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2"
    // InternalEssentialOCL.g:14139:1: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 : ( ruleMultiplicityCS ) ;
    public final void rule__TemplateBindingCS__OwnedMultiplicityAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14143:1: ( ( ruleMultiplicityCS ) )
            // InternalEssentialOCL.g:14144:1: ( ruleMultiplicityCS )
            {
            // InternalEssentialOCL.g:14144:1: ( ruleMultiplicityCS )
            // InternalEssentialOCL.g:14145:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2"


    // $ANTLR start "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment"
    // InternalEssentialOCL.g:14154:1: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment : ( ruleTypeRefCS ) ;
    public final void rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14158:1: ( ( ruleTypeRefCS ) )
            // InternalEssentialOCL.g:14159:1: ( ruleTypeRefCS )
            {
            // InternalEssentialOCL.g:14159:1: ( ruleTypeRefCS )
            // InternalEssentialOCL.g:14160:1: ruleTypeRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment"


    // $ANTLR start "rule__TypeParameterCS__NameAssignment_0"
    // InternalEssentialOCL.g:14171:1: rule__TypeParameterCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TypeParameterCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14175:1: ( ( ruleUnrestrictedName ) )
            // InternalEssentialOCL.g:14176:1: ( ruleUnrestrictedName )
            {
            // InternalEssentialOCL.g:14176:1: ( ruleUnrestrictedName )
            // InternalEssentialOCL.g:14177:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__NameAssignment_0"


    // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_1"
    // InternalEssentialOCL.g:14186:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14190:1: ( ( ruleTypedRefCS ) )
            // InternalEssentialOCL.g:14191:1: ( ruleTypedRefCS )
            {
            // InternalEssentialOCL.g:14191:1: ( ruleTypedRefCS )
            // InternalEssentialOCL.g:14192:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_1"


    // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1"
    // InternalEssentialOCL.g:14201:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14205:1: ( ( ruleTypedRefCS ) )
            // InternalEssentialOCL.g:14206:1: ( ruleTypedRefCS )
            {
            // InternalEssentialOCL.g:14206:1: ( ruleTypedRefCS )
            // InternalEssentialOCL.g:14207:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1"


    // $ANTLR start "rule__TypedTypeRefCS__OwnedPathNameAssignment_0"
    // InternalEssentialOCL.g:14216:1: rule__TypedTypeRefCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypedTypeRefCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14220:1: ( ( rulePathNameCS ) )
            // InternalEssentialOCL.g:14221:1: ( rulePathNameCS )
            {
            // InternalEssentialOCL.g:14221:1: ( rulePathNameCS )
            // InternalEssentialOCL.g:14222:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1"
    // InternalEssentialOCL.g:14231:1: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 : ( ruleTemplateBindingCS ) ;
    public final void rule__TypedTypeRefCS__OwnedBindingAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14235:1: ( ( ruleTemplateBindingCS ) )
            // InternalEssentialOCL.g:14236:1: ( ruleTemplateBindingCS )
            {
            // InternalEssentialOCL.g:14236:1: ( ruleTemplateBindingCS )
            // InternalEssentialOCL.g:14237:1: ruleTemplateBindingCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateBindingCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1"


    // $ANTLR start "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1"
    // InternalEssentialOCL.g:14246:1: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalEssentialOCL.g:14250:1: ( ( ruleTypedRefCS ) )
            // InternalEssentialOCL.g:14251:1: ( ruleTypedRefCS )
            {
            // InternalEssentialOCL.g:14251:1: ( ruleTypedRefCS )
            // InternalEssentialOCL.g:14252:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1"

    // $ANTLR start synpred55_InternalEssentialOCL
    public final void synpred55_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3057:6: ( ( ruleTypeLiteralCS ) )
        // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS )
        {
        // InternalEssentialOCL.g:3057:6: ( ruleTypeLiteralCS )
        // InternalEssentialOCL.g:3058:1: ruleTypeLiteralCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTypeLiteralCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred55_InternalEssentialOCL

    // $ANTLR start synpred56_InternalEssentialOCL
    public final void synpred56_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3079:1: ( ( ( rule__ExpCS__Group_0__0 ) ) )
        // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) )
        {
        // InternalEssentialOCL.g:3079:1: ( ( rule__ExpCS__Group_0__0 ) )
        // InternalEssentialOCL.g:3080:1: ( rule__ExpCS__Group_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getExpCSAccess().getGroup_0());
        }
        // InternalEssentialOCL.g:3081:1: ( rule__ExpCS__Group_0__0 )
        // InternalEssentialOCL.g:3081:2: rule__ExpCS__Group_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__ExpCS__Group_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred56_InternalEssentialOCL

    // $ANTLR start synpred63_InternalEssentialOCL
    public final void synpred63_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3169:6: ( ( ruleTupleLiteralExpCS ) )
        // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS )
        {
        // InternalEssentialOCL.g:3169:6: ( ruleTupleLiteralExpCS )
        // InternalEssentialOCL.g:3170:1: ruleTupleLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTupleLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred63_InternalEssentialOCL

    // $ANTLR start synpred64_InternalEssentialOCL
    public final void synpred64_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3175:6: ( ( ruleMapLiteralExpCS ) )
        // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS )
        {
        // InternalEssentialOCL.g:3175:6: ( ruleMapLiteralExpCS )
        // InternalEssentialOCL.g:3176:1: ruleMapLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleMapLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred64_InternalEssentialOCL

    // $ANTLR start synpred65_InternalEssentialOCL
    public final void synpred65_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3181:6: ( ( ruleCollectionLiteralExpCS ) )
        // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS )
        {
        // InternalEssentialOCL.g:3181:6: ( ruleCollectionLiteralExpCS )
        // InternalEssentialOCL.g:3182:1: ruleCollectionLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleCollectionLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred65_InternalEssentialOCL

    // $ANTLR start synpred67_InternalEssentialOCL
    public final void synpred67_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3193:6: ( ( ruleTypeLiteralExpCS ) )
        // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS )
        {
        // InternalEssentialOCL.g:3193:6: ( ruleTypeLiteralExpCS )
        // InternalEssentialOCL.g:3194:1: ruleTypeLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTypeLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred67_InternalEssentialOCL

    // $ANTLR start synpred71_InternalEssentialOCL
    public final void synpred71_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3265:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) )
        // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
        {
        // InternalEssentialOCL.g:3265:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
        // InternalEssentialOCL.g:3266:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
        }
        // InternalEssentialOCL.g:3267:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
        // InternalEssentialOCL.g:3267:2: rule__NavigatingArgCS__Group_0_1_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingArgCS__Group_0_1_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred71_InternalEssentialOCL

    // $ANTLR start synpred72_InternalEssentialOCL
    public final void synpred72_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3271:6: ( ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) )
        // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
        {
        // InternalEssentialOCL.g:3271:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
        // InternalEssentialOCL.g:3272:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
        }
        // InternalEssentialOCL.g:3273:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
        // InternalEssentialOCL.g:3273:2: rule__NavigatingArgCS__Group_0_1_1__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingArgCS__Group_0_1_1__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred72_InternalEssentialOCL

    // $ANTLR start synpred76_InternalEssentialOCL
    public final void synpred76_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3371:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) )
        // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
        {
        // InternalEssentialOCL.g:3371:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
        // InternalEssentialOCL.g:3372:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
        }
        // InternalEssentialOCL.g:3373:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
        // InternalEssentialOCL.g:3373:2: rule__NavigatingCommaArgCS__Group_2_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingCommaArgCS__Group_2_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred76_InternalEssentialOCL

    // $ANTLR start synpred77_InternalEssentialOCL
    public final void synpred77_InternalEssentialOCL_fragment() throws RecognitionException {
        // InternalEssentialOCL.g:3377:6: ( ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) )
        // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
        {
        // InternalEssentialOCL.g:3377:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
        // InternalEssentialOCL.g:3378:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
        }
        // InternalEssentialOCL.g:3379:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
        // InternalEssentialOCL.g:3379:2: rule__NavigatingCommaArgCS__Group_2_1__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingCommaArgCS__Group_2_1__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred77_InternalEssentialOCL

    // Delegated rules

    public final boolean synpred64_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred64_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred67_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred67_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred56_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred56_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred76_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred76_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred72_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred72_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred63_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred63_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred65_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred65_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred77_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred77_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred71_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred71_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }
    public final boolean synpred55_InternalEssentialOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred55_InternalEssentialOCL_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA17 dfa17 = new DFA17(this);
    protected DFA18 dfa18 = new DFA18(this);
    protected DFA21 dfa21 = new DFA21(this);
    static final String dfa_1s = "\23\uffff";
    static final String dfa_2s = "\1\6\12\uffff\5\0\3\uffff";
    static final String dfa_3s = "\1\66\12\uffff\5\0\3\uffff";
    static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\16\uffff\1\3";
    static final String dfa_5s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\3\uffff}>";
    static final String[] dfa_6s = {
            "\2\1\40\uffff\12\3\1\13\1\14\1\15\1\16\1\17",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
    static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s);
    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
    static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s);
    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
    static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s);

    class DFA17 extends DFA {

        public DFA17(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 17;
            this.eot = dfa_1;
            this.eof = dfa_1;
            this.min = dfa_2;
            this.max = dfa_3;
            this.accept = dfa_4;
            this.special = dfa_5;
            this.transition = dfa_6;
        }
        public String getDescription() {
            return "3046:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA17_11 = input.LA(1);


                        int index17_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred55_InternalEssentialOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index17_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA17_12 = input.LA(1);


                        int index17_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred55_InternalEssentialOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index17_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA17_13 = input.LA(1);


                        int index17_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred55_InternalEssentialOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index17_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 :
                        int LA17_14 = input.LA(1);


                        int index17_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred55_InternalEssentialOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index17_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 :
                        int LA17_15 = input.LA(1);


                        int index17_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred55_InternalEssentialOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index17_15);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 17, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_7s = "\41\uffff";
    static final String dfa_8s = "\1\4\3\0\35\uffff";
    static final String dfa_9s = "\1\125\3\0\35\uffff";
    static final String dfa_10s = "\4\uffff\1\1\33\uffff\1\2";
    static final String dfa_11s = "\1\uffff\1\0\1\1\1\2\35\uffff}>";
    static final String[] dfa_12s = {
            "\4\4\10\uffff\1\1\1\2\1\3\1\4\24\uffff\17\4\4\uffff\1\4\7\uffff\3\4\4\uffff\1\4\4\uffff\1\40\1\4\3\uffff\2\4",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
    static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s);
    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
    static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s);
    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
    static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s);

    class DFA18 extends DFA {

        public DFA18(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 18;
            this.eot = dfa_7;
            this.eof = dfa_7;
            this.min = dfa_8;
            this.max = dfa_9;
            this.accept = dfa_10;
            this.special = dfa_11;
            this.transition = dfa_12;
        }
        public String getDescription() {
            return "3074:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA18_1 = input.LA(1);


                        int index18_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred56_InternalEssentialOCL()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index18_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA18_2 = input.LA(1);


                        int index18_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred56_InternalEssentialOCL()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index18_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA18_3 = input.LA(1);


                        int index18_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred56_InternalEssentialOCL()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index18_3);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 18, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_13s = "\40\uffff";
    static final String dfa_14s = "\1\4\12\uffff\7\0\16\uffff";
    static final String dfa_15s = "\1\125\12\uffff\7\0\16\uffff";
    static final String dfa_16s = "\1\uffff\1\1\1\2\1\3\1\4\15\uffff\1\10\1\11\7\uffff\1\12\1\uffff\1\5\1\6\1\7";
    static final String dfa_17s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\16\uffff}>";
    static final String[] dfa_18s = {
            "\2\4\2\33\13\uffff\1\4\24\uffff\1\14\1\13\10\23\1\15\1\16\1\17\1\20\1\21\4\uffff\1\1\7\uffff\1\22\2\4\4\uffff\1\2\5\uffff\1\3\3\uffff\2\4",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s);
    static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s);
    static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s);
    static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s);
    static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s);
    static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s);

    class DFA21 extends DFA {

        public DFA21(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 21;
            this.eot = dfa_13;
            this.eof = dfa_13;
            this.min = dfa_14;
            this.max = dfa_15;
            this.accept = dfa_16;
            this.special = dfa_17;
            this.transition = dfa_18;
        }
        public String getDescription() {
            return "3140:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA21_11 = input.LA(1);


                        int index21_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred63_InternalEssentialOCL()) ) {s = 29;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA21_12 = input.LA(1);


                        int index21_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred64_InternalEssentialOCL()) ) {s = 30;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA21_13 = input.LA(1);


                        int index21_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred65_InternalEssentialOCL()) ) {s = 31;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 :
                        int LA21_14 = input.LA(1);


                        int index21_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred65_InternalEssentialOCL()) ) {s = 31;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 :
                        int LA21_15 = input.LA(1);


                        int index21_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred65_InternalEssentialOCL()) ) {s = 31;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_15);
                        if ( s>=0 ) return s;
                        break;
                    case 5 :
                        int LA21_16 = input.LA(1);


                        int index21_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred65_InternalEssentialOCL()) ) {s = 31;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_16);
                        if ( s>=0 ) return s;
                        break;
                    case 6 :
                        int LA21_17 = input.LA(1);


                        int index21_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred65_InternalEssentialOCL()) ) {s = 31;}

                        else if ( (synpred67_InternalEssentialOCL()) ) {s = 19;}


                        input.seek(index21_17);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 21, _s, input);
            error(nvae);
            throw nvae;
        }
    }


    private static class FollowSets000 {
        public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
        public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
        public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000022L});
        public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000000020L});
        public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0800000000000000L});
        public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x007FFF00000000C0L});
        public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x1000000000000000L,0x0000000000000080L});
        public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x2000000000000000L});
        public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x1000000000000000L});
        public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x10000000000000C0L});
        public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x2000000000000002L});
        public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x00000000000000C0L});
        public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x4000000000000000L});
        public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x8000000000000000L});
        public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x487FFF00000F00F0L,0x0000000000318439L});
        public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x487FFF00000F00F0L,0x0000000000318438L});
        public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
        public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000318438L});
        public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000004L});
        public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000004000000L});
        public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
        public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000318439L});
        public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0180000000000000L});
        public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000001L});
        public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x4000000004000000L});
        public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000000080000L});
        public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000010L});
        public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000080030L,0x0000000000300030L});
        public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
        public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x000000FFFFF90000L});
        public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000070000L});
        public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x087FFF00000F00F0L,0x0000000000310438L});
        public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x8800000000000000L,0x0000000000400080L});
        public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000080L});
        public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
        public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x00000000000000E0L,0x0000000000000001L});
        public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x00000000000000E0L});
        public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x587FFF00000F00F0L,0x0000000000318438L});
        public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x2000000000000000L,0x0000000001800000L});
        public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x2000000000000002L,0x0000000001800000L});
        public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000100L});
        public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x4180000000000000L,0x0000000000000200L});
        public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0180000004000000L});
        public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
        public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000000L,0x0000000000005000L});
        public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});
        public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
        public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000200L});
        public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x4800000004000000L});
        public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
        public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x0000000000080010L});
        public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0400000000280010L});
        public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0200000000000000L,0x0000000002000100L});
        public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020000L});
        public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000002L,0x0000000000020000L});
        public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x2000000000000000L,0x0000000000000080L});
        public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x04000000000000C0L});
        public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x0000000000000000L,0x0000000000040000L});
        public static final BitSet FOLLOW_59 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
        public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x0000000000000002L,0x0000000000080000L});
    }


}