package org.xtext.example.extendingOCL.ide.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.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
import org.xtext.example.extendingOCL.services.EOCLGrammarAccess;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
@SuppressWarnings("all")
public class InternalEOCLParser 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'", "'*'", "'/'", "'+'", "'>'", "'<'", "'>='", "'<='", "'='", "'<>'", "'and'", "'or'", "'xor'", "'implies'", "'.'", "'->'", "'?.'", "'?->'", "'Map'", "'Tuple'", "'Boolean'", "'Integer'", "'Real'", "'String'", "'UnlimitedNatural'", "'OclAny'", "'OclInvalid'", "'OclVoid'", "'Set'", "'Bag'", "'Sequence'", "'Collection'", "'OrderedSet'", "'|?'", "'?'", "'Hello'", "'('", "')'", "','", "':'", "'{'", "'}'", "'..'", "'++'", "'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__45=45;
    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__42=42;
    public static final int T__43=43;

    // delegates
    // delegators


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

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


    	private EOCLGrammarAccess grammarAccess;

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

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

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



    // $ANTLR start "entryRuleGreeting"
    // InternalEOCL.g:54:1: entryRuleGreeting : ruleGreeting EOF ;
    public final void entryRuleGreeting() throws RecognitionException {
        try {
            // InternalEOCL.g:55:1: ( ruleGreeting EOF )
            // InternalEOCL.g:56:1: ruleGreeting EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGreetingRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleGreeting();

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

            }

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


    // $ANTLR start "ruleGreeting"
    // InternalEOCL.g:63:1: ruleGreeting : ( ( rule__Greeting__Group__0 ) ) ;
    public final void ruleGreeting() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:67:2: ( ( ( rule__Greeting__Group__0 ) ) )
            // InternalEOCL.g:68:2: ( ( rule__Greeting__Group__0 ) )
            {
            // InternalEOCL.g:68:2: ( ( rule__Greeting__Group__0 ) )
            // InternalEOCL.g:69:3: ( rule__Greeting__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGreetingAccess().getGroup()); 
            }
            // InternalEOCL.g:70:3: ( rule__Greeting__Group__0 )
            // InternalEOCL.g:70:4: rule__Greeting__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Greeting__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleModel"
    // InternalEOCL.g:79:1: entryRuleModel : ruleModel EOF ;
    public final void entryRuleModel() throws RecognitionException {
        try {
            // InternalEOCL.g:80:1: ( ruleModel EOF )
            // InternalEOCL.g:81:1: ruleModel EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleModel();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:92:2: ( ( ( rule__Model__OwnedExpressionAssignment ) ) )
            // InternalEOCL.g:93:2: ( ( rule__Model__OwnedExpressionAssignment ) )
            {
            // InternalEOCL.g:93:2: ( ( rule__Model__OwnedExpressionAssignment ) )
            // InternalEOCL.g:94:3: ( rule__Model__OwnedExpressionAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelAccess().getOwnedExpressionAssignment()); 
            }
            // InternalEOCL.g:95:3: ( rule__Model__OwnedExpressionAssignment )
            // InternalEOCL.g:95:4: rule__Model__OwnedExpressionAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:104:1: entryRuleEssentialOCLUnaryOperatorName : ruleEssentialOCLUnaryOperatorName EOF ;
    public final void entryRuleEssentialOCLUnaryOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:105:1: ( ruleEssentialOCLUnaryOperatorName EOF )
            // InternalEOCL.g:106:1: ruleEssentialOCLUnaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnaryOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEssentialOCLUnaryOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:117:2: ( ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) )
            // InternalEOCL.g:118:2: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            {
            // InternalEOCL.g:118:2: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            // InternalEOCL.g:119:3: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives()); 
            }
            // InternalEOCL.g:120:3: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            // InternalEOCL.g:120:4: rule__EssentialOCLUnaryOperatorName__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:129:1: entryRuleEssentialOCLInfixOperatorName : ruleEssentialOCLInfixOperatorName EOF ;
    public final void entryRuleEssentialOCLInfixOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:130:1: ( ruleEssentialOCLInfixOperatorName EOF )
            // InternalEOCL.g:131:1: ruleEssentialOCLInfixOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLInfixOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEssentialOCLInfixOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:142:2: ( ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) )
            // InternalEOCL.g:143:2: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            {
            // InternalEOCL.g:143:2: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            // InternalEOCL.g:144:3: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives()); 
            }
            // InternalEOCL.g:145:3: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            // InternalEOCL.g:145:4: rule__EssentialOCLInfixOperatorName__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:154:1: entryRuleEssentialOCLNavigationOperatorName : ruleEssentialOCLNavigationOperatorName EOF ;
    public final void entryRuleEssentialOCLNavigationOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:155:1: ( ruleEssentialOCLNavigationOperatorName EOF )
            // InternalEOCL.g:156:1: ruleEssentialOCLNavigationOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLNavigationOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEssentialOCLNavigationOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:167:2: ( ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) )
            // InternalEOCL.g:168:2: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            {
            // InternalEOCL.g:168:2: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            // InternalEOCL.g:169:3: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives()); 
            }
            // InternalEOCL.g:170:3: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            // InternalEOCL.g:170:4: rule__EssentialOCLNavigationOperatorName__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:179:1: entryRuleBinaryOperatorName : ruleBinaryOperatorName EOF ;
    public final void entryRuleBinaryOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:180:1: ( ruleBinaryOperatorName EOF )
            // InternalEOCL.g:181:1: ruleBinaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBinaryOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleBinaryOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:192:2: ( ( ( rule__BinaryOperatorName__Alternatives ) ) )
            // InternalEOCL.g:193:2: ( ( rule__BinaryOperatorName__Alternatives ) )
            {
            // InternalEOCL.g:193:2: ( ( rule__BinaryOperatorName__Alternatives ) )
            // InternalEOCL.g:194:3: ( rule__BinaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBinaryOperatorNameAccess().getAlternatives()); 
            }
            // InternalEOCL.g:195:3: ( rule__BinaryOperatorName__Alternatives )
            // InternalEOCL.g:195:4: rule__BinaryOperatorName__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:204:1: entryRuleInfixOperatorName : ruleInfixOperatorName EOF ;
    public final void entryRuleInfixOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:205:1: ( ruleInfixOperatorName EOF )
            // InternalEOCL.g:206:1: ruleInfixOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInfixOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleInfixOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:217:2: ( ( ruleEssentialOCLInfixOperatorName ) )
            // InternalEOCL.g:218:2: ( ruleEssentialOCLInfixOperatorName )
            {
            // InternalEOCL.g:218:2: ( ruleEssentialOCLInfixOperatorName )
            // InternalEOCL.g:219:3: ruleEssentialOCLInfixOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:229:1: entryRuleNavigationOperatorName : ruleNavigationOperatorName EOF ;
    public final void entryRuleNavigationOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:230:1: ( ruleNavigationOperatorName EOF )
            // InternalEOCL.g:231:1: ruleNavigationOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigationOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:242:2: ( ( ruleEssentialOCLNavigationOperatorName ) )
            // InternalEOCL.g:243:2: ( ruleEssentialOCLNavigationOperatorName )
            {
            // InternalEOCL.g:243:2: ( ruleEssentialOCLNavigationOperatorName )
            // InternalEOCL.g:244:3: ruleEssentialOCLNavigationOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:254:1: entryRuleUnaryOperatorName : ruleUnaryOperatorName EOF ;
    public final void entryRuleUnaryOperatorName() throws RecognitionException {
        try {
            // InternalEOCL.g:255:1: ( ruleUnaryOperatorName EOF )
            // InternalEOCL.g:256:1: ruleUnaryOperatorName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnaryOperatorNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUnaryOperatorName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:267:2: ( ( ruleEssentialOCLUnaryOperatorName ) )
            // InternalEOCL.g:268:2: ( ruleEssentialOCLUnaryOperatorName )
            {
            // InternalEOCL.g:268:2: ( ruleEssentialOCLUnaryOperatorName )
            // InternalEOCL.g:269:3: ruleEssentialOCLUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:279:1: entryRuleEssentialOCLUnrestrictedName : ruleEssentialOCLUnrestrictedName EOF ;
    public final void entryRuleEssentialOCLUnrestrictedName() throws RecognitionException {
        try {
            // InternalEOCL.g:280:1: ( ruleEssentialOCLUnrestrictedName EOF )
            // InternalEOCL.g:281:1: ruleEssentialOCLUnrestrictedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnrestrictedNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEssentialOCLUnrestrictedName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:292:2: ( ( ruleIdentifier ) )
            // InternalEOCL.g:293:2: ( ruleIdentifier )
            {
            // InternalEOCL.g:293:2: ( ruleIdentifier )
            // InternalEOCL.g:294:3: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:304:1: entryRuleUnrestrictedName : ruleUnrestrictedName EOF ;
    public final void entryRuleUnrestrictedName() throws RecognitionException {
        try {
            // InternalEOCL.g:305:1: ( ruleUnrestrictedName EOF )
            // InternalEOCL.g:306:1: ruleUnrestrictedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnrestrictedNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUnrestrictedName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:317:2: ( ( ruleEssentialOCLUnrestrictedName ) )
            // InternalEOCL.g:318:2: ( ruleEssentialOCLUnrestrictedName )
            {
            // InternalEOCL.g:318:2: ( ruleEssentialOCLUnrestrictedName )
            // InternalEOCL.g:319:3: ruleEssentialOCLUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:329:1: entryRuleEssentialOCLUnreservedName : ruleEssentialOCLUnreservedName EOF ;
    public final void entryRuleEssentialOCLUnreservedName() throws RecognitionException {
        try {
            // InternalEOCL.g:330:1: ( ruleEssentialOCLUnreservedName EOF )
            // InternalEOCL.g:331:1: ruleEssentialOCLUnreservedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnreservedNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEssentialOCLUnreservedName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:342:2: ( ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) )
            // InternalEOCL.g:343:2: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            {
            // InternalEOCL.g:343:2: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            // InternalEOCL.g:344:3: ( rule__EssentialOCLUnreservedName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives()); 
            }
            // InternalEOCL.g:345:3: ( rule__EssentialOCLUnreservedName__Alternatives )
            // InternalEOCL.g:345:4: rule__EssentialOCLUnreservedName__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:354:1: entryRuleUnreservedName : ruleUnreservedName EOF ;
    public final void entryRuleUnreservedName() throws RecognitionException {
        try {
            // InternalEOCL.g:355:1: ( ruleUnreservedName EOF )
            // InternalEOCL.g:356:1: ruleUnreservedName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnreservedNameRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUnreservedName();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:367:2: ( ( ruleEssentialOCLUnreservedName ) )
            // InternalEOCL.g:368:2: ( ruleEssentialOCLUnreservedName )
            {
            // InternalEOCL.g:368:2: ( ruleEssentialOCLUnreservedName )
            // InternalEOCL.g:369:3: ruleEssentialOCLUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:379:1: entryRuleURIFirstPathElementCS : ruleURIFirstPathElementCS EOF ;
    public final void entryRuleURIFirstPathElementCS() throws RecognitionException {
        try {
            // InternalEOCL.g:380:1: ( ruleURIFirstPathElementCS EOF )
            // InternalEOCL.g:381:1: ruleURIFirstPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleURIFirstPathElementCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:392:2: ( ( ( rule__URIFirstPathElementCS__Alternatives ) ) )
            // InternalEOCL.g:393:2: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            {
            // InternalEOCL.g:393:2: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            // InternalEOCL.g:394:3: ( rule__URIFirstPathElementCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:395:3: ( rule__URIFirstPathElementCS__Alternatives )
            // InternalEOCL.g:395:4: rule__URIFirstPathElementCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:404:1: entryRulePrimitiveTypeIdentifier : rulePrimitiveTypeIdentifier EOF ;
    public final void entryRulePrimitiveTypeIdentifier() throws RecognitionException {
        try {
            // InternalEOCL.g:405:1: ( rulePrimitiveTypeIdentifier EOF )
            // InternalEOCL.g:406:1: rulePrimitiveTypeIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeIdentifierRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimitiveTypeIdentifier();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:417:2: ( ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) )
            // InternalEOCL.g:418:2: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            {
            // InternalEOCL.g:418:2: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            // InternalEOCL.g:419:3: ( rule__PrimitiveTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives()); 
            }
            // InternalEOCL.g:420:3: ( rule__PrimitiveTypeIdentifier__Alternatives )
            // InternalEOCL.g:420:4: rule__PrimitiveTypeIdentifier__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:429:1: entryRulePrimitiveTypeCS : rulePrimitiveTypeCS EOF ;
    public final void entryRulePrimitiveTypeCS() throws RecognitionException {
        try {
            // InternalEOCL.g:430:1: ( rulePrimitiveTypeCS EOF )
            // InternalEOCL.g:431:1: rulePrimitiveTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimitiveTypeCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:442:2: ( ( ( rule__PrimitiveTypeCS__NameAssignment ) ) )
            // InternalEOCL.g:443:2: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            {
            // InternalEOCL.g:443:2: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            // InternalEOCL.g:444:3: ( rule__PrimitiveTypeCS__NameAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment()); 
            }
            // InternalEOCL.g:445:3: ( rule__PrimitiveTypeCS__NameAssignment )
            // InternalEOCL.g:445:4: rule__PrimitiveTypeCS__NameAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:454:1: entryRuleCollectionTypeIdentifier : ruleCollectionTypeIdentifier EOF ;
    public final void entryRuleCollectionTypeIdentifier() throws RecognitionException {
        try {
            // InternalEOCL.g:455:1: ( ruleCollectionTypeIdentifier EOF )
            // InternalEOCL.g:456:1: ruleCollectionTypeIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeIdentifierRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectionTypeIdentifier();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:467:2: ( ( ( rule__CollectionTypeIdentifier__Alternatives ) ) )
            // InternalEOCL.g:468:2: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            {
            // InternalEOCL.g:468:2: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            // InternalEOCL.g:469:3: ( rule__CollectionTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives()); 
            }
            // InternalEOCL.g:470:3: ( rule__CollectionTypeIdentifier__Alternatives )
            // InternalEOCL.g:470:4: rule__CollectionTypeIdentifier__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:479:1: entryRuleCollectionTypeCS : ruleCollectionTypeCS EOF ;
    public final void entryRuleCollectionTypeCS() throws RecognitionException {
        try {
            // InternalEOCL.g:480:1: ( ruleCollectionTypeCS EOF )
            // InternalEOCL.g:481:1: ruleCollectionTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectionTypeCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:492:2: ( ( ( rule__CollectionTypeCS__Group__0 ) ) )
            // InternalEOCL.g:493:2: ( ( rule__CollectionTypeCS__Group__0 ) )
            {
            // InternalEOCL.g:493:2: ( ( rule__CollectionTypeCS__Group__0 ) )
            // InternalEOCL.g:494:3: ( rule__CollectionTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup()); 
            }
            // InternalEOCL.g:495:3: ( rule__CollectionTypeCS__Group__0 )
            // InternalEOCL.g:495:4: rule__CollectionTypeCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:504:1: entryRuleMapTypeCS : ruleMapTypeCS EOF ;
    public final void entryRuleMapTypeCS() throws RecognitionException {
        try {
            // InternalEOCL.g:505:1: ( ruleMapTypeCS EOF )
            // InternalEOCL.g:506:1: ruleMapTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMapTypeCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:517:2: ( ( ( rule__MapTypeCS__Group__0 ) ) )
            // InternalEOCL.g:518:2: ( ( rule__MapTypeCS__Group__0 ) )
            {
            // InternalEOCL.g:518:2: ( ( rule__MapTypeCS__Group__0 ) )
            // InternalEOCL.g:519:3: ( rule__MapTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup()); 
            }
            // InternalEOCL.g:520:3: ( rule__MapTypeCS__Group__0 )
            // InternalEOCL.g:520:4: rule__MapTypeCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:529:1: entryRuleTupleTypeCS : ruleTupleTypeCS EOF ;
    public final void entryRuleTupleTypeCS() throws RecognitionException {
        try {
            // InternalEOCL.g:530:1: ( ruleTupleTypeCS EOF )
            // InternalEOCL.g:531:1: ruleTupleTypeCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTupleTypeCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:542:2: ( ( ( rule__TupleTypeCS__Group__0 ) ) )
            // InternalEOCL.g:543:2: ( ( rule__TupleTypeCS__Group__0 ) )
            {
            // InternalEOCL.g:543:2: ( ( rule__TupleTypeCS__Group__0 ) )
            // InternalEOCL.g:544:3: ( rule__TupleTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup()); 
            }
            // InternalEOCL.g:545:3: ( rule__TupleTypeCS__Group__0 )
            // InternalEOCL.g:545:4: rule__TupleTypeCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:554:1: entryRuleTuplePartCS : ruleTuplePartCS EOF ;
    public final void entryRuleTuplePartCS() throws RecognitionException {
        try {
            // InternalEOCL.g:555:1: ( ruleTuplePartCS EOF )
            // InternalEOCL.g:556:1: ruleTuplePartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTuplePartCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:567:2: ( ( ( rule__TuplePartCS__Group__0 ) ) )
            // InternalEOCL.g:568:2: ( ( rule__TuplePartCS__Group__0 ) )
            {
            // InternalEOCL.g:568:2: ( ( rule__TuplePartCS__Group__0 ) )
            // InternalEOCL.g:569:3: ( rule__TuplePartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getGroup()); 
            }
            // InternalEOCL.g:570:3: ( rule__TuplePartCS__Group__0 )
            // InternalEOCL.g:570:4: rule__TuplePartCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:579:1: entryRuleCollectionLiteralExpCS : ruleCollectionLiteralExpCS EOF ;
    public final void entryRuleCollectionLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:580:1: ( ruleCollectionLiteralExpCS EOF )
            // InternalEOCL.g:581:1: ruleCollectionLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectionLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:592:2: ( ( ( rule__CollectionLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:593:2: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:593:2: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:594:3: ( rule__CollectionLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:595:3: ( rule__CollectionLiteralExpCS__Group__0 )
            // InternalEOCL.g:595:4: rule__CollectionLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:604:1: entryRuleCollectionLiteralPartCS : ruleCollectionLiteralPartCS EOF ;
    public final void entryRuleCollectionLiteralPartCS() throws RecognitionException {
        try {
            // InternalEOCL.g:605:1: ( ruleCollectionLiteralPartCS EOF )
            // InternalEOCL.g:606:1: ruleCollectionLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectionLiteralPartCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:617:2: ( ( ( rule__CollectionLiteralPartCS__Alternatives ) ) )
            // InternalEOCL.g:618:2: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            {
            // InternalEOCL.g:618:2: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            // InternalEOCL.g:619:3: ( rule__CollectionLiteralPartCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:620:3: ( rule__CollectionLiteralPartCS__Alternatives )
            // InternalEOCL.g:620:4: rule__CollectionLiteralPartCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:629:1: entryRuleCollectionPatternCS : ruleCollectionPatternCS EOF ;
    public final void entryRuleCollectionPatternCS() throws RecognitionException {
        try {
            // InternalEOCL.g:630:1: ( ruleCollectionPatternCS EOF )
            // InternalEOCL.g:631:1: ruleCollectionPatternCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectionPatternCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:642:2: ( ( ( rule__CollectionPatternCS__Group__0 ) ) )
            // InternalEOCL.g:643:2: ( ( rule__CollectionPatternCS__Group__0 ) )
            {
            // InternalEOCL.g:643:2: ( ( rule__CollectionPatternCS__Group__0 ) )
            // InternalEOCL.g:644:3: ( rule__CollectionPatternCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup()); 
            }
            // InternalEOCL.g:645:3: ( rule__CollectionPatternCS__Group__0 )
            // InternalEOCL.g:645:4: rule__CollectionPatternCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:654:1: entryRuleShadowPartCS : ruleShadowPartCS EOF ;
    public final void entryRuleShadowPartCS() throws RecognitionException {
        try {
            // InternalEOCL.g:655:1: ( ruleShadowPartCS EOF )
            // InternalEOCL.g:656:1: ruleShadowPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleShadowPartCS();

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

            }

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


    // $ANTLR start "ruleShadowPartCS"
    // InternalEOCL.g:663:1: ruleShadowPartCS : ( ( rule__ShadowPartCS__Group__0 ) ) ;
    public final void ruleShadowPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:667:2: ( ( ( rule__ShadowPartCS__Group__0 ) ) )
            // InternalEOCL.g:668:2: ( ( rule__ShadowPartCS__Group__0 ) )
            {
            // InternalEOCL.g:668:2: ( ( rule__ShadowPartCS__Group__0 ) )
            // InternalEOCL.g:669:3: ( rule__ShadowPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getGroup()); 
            }
            // InternalEOCL.g:670:3: ( rule__ShadowPartCS__Group__0 )
            // InternalEOCL.g:670:4: rule__ShadowPartCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePatternExpCS"
    // InternalEOCL.g:679:1: entryRulePatternExpCS : rulePatternExpCS EOF ;
    public final void entryRulePatternExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:680:1: ( rulePatternExpCS EOF )
            // InternalEOCL.g:681:1: rulePatternExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePatternExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:692:2: ( ( ( rule__PatternExpCS__Group__0 ) ) )
            // InternalEOCL.g:693:2: ( ( rule__PatternExpCS__Group__0 ) )
            {
            // InternalEOCL.g:693:2: ( ( rule__PatternExpCS__Group__0 ) )
            // InternalEOCL.g:694:3: ( rule__PatternExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:695:3: ( rule__PatternExpCS__Group__0 )
            // InternalEOCL.g:695:4: rule__PatternExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:704:1: entryRuleLambdaLiteralExpCS : ruleLambdaLiteralExpCS EOF ;
    public final void entryRuleLambdaLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:705:1: ( ruleLambdaLiteralExpCS EOF )
            // InternalEOCL.g:706:1: ruleLambdaLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLambdaLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:717:2: ( ( ( rule__LambdaLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:718:2: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:718:2: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:719:3: ( rule__LambdaLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:720:3: ( rule__LambdaLiteralExpCS__Group__0 )
            // InternalEOCL.g:720:4: rule__LambdaLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:729:1: entryRuleMapLiteralExpCS : ruleMapLiteralExpCS EOF ;
    public final void entryRuleMapLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:730:1: ( ruleMapLiteralExpCS EOF )
            // InternalEOCL.g:731:1: ruleMapLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMapLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:742:2: ( ( ( rule__MapLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:743:2: ( ( rule__MapLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:743:2: ( ( rule__MapLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:744:3: ( rule__MapLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:745:3: ( rule__MapLiteralExpCS__Group__0 )
            // InternalEOCL.g:745:4: rule__MapLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:754:1: entryRuleMapLiteralPartCS : ruleMapLiteralPartCS EOF ;
    public final void entryRuleMapLiteralPartCS() throws RecognitionException {
        try {
            // InternalEOCL.g:755:1: ( ruleMapLiteralPartCS EOF )
            // InternalEOCL.g:756:1: ruleMapLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMapLiteralPartCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:767:2: ( ( ( rule__MapLiteralPartCS__Group__0 ) ) )
            // InternalEOCL.g:768:2: ( ( rule__MapLiteralPartCS__Group__0 ) )
            {
            // InternalEOCL.g:768:2: ( ( rule__MapLiteralPartCS__Group__0 ) )
            // InternalEOCL.g:769:3: ( rule__MapLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getGroup()); 
            }
            // InternalEOCL.g:770:3: ( rule__MapLiteralPartCS__Group__0 )
            // InternalEOCL.g:770:4: rule__MapLiteralPartCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:779:1: entryRulePrimitiveLiteralExpCS : rulePrimitiveLiteralExpCS EOF ;
    public final void entryRulePrimitiveLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:780:1: ( rulePrimitiveLiteralExpCS EOF )
            // InternalEOCL.g:781:1: rulePrimitiveLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimitiveLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:792:2: ( ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) )
            // InternalEOCL.g:793:2: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            {
            // InternalEOCL.g:793:2: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            // InternalEOCL.g:794:3: ( rule__PrimitiveLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:795:3: ( rule__PrimitiveLiteralExpCS__Alternatives )
            // InternalEOCL.g:795:4: rule__PrimitiveLiteralExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:804:1: entryRuleTupleLiteralExpCS : ruleTupleLiteralExpCS EOF ;
    public final void entryRuleTupleLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:805:1: ( ruleTupleLiteralExpCS EOF )
            // InternalEOCL.g:806:1: ruleTupleLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTupleLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:817:2: ( ( ( rule__TupleLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:818:2: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:818:2: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:819:3: ( rule__TupleLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:820:3: ( rule__TupleLiteralExpCS__Group__0 )
            // InternalEOCL.g:820:4: rule__TupleLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:829:1: entryRuleTupleLiteralPartCS : ruleTupleLiteralPartCS EOF ;
    public final void entryRuleTupleLiteralPartCS() throws RecognitionException {
        try {
            // InternalEOCL.g:830:1: ( ruleTupleLiteralPartCS EOF )
            // InternalEOCL.g:831:1: ruleTupleLiteralPartCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTupleLiteralPartCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:842:2: ( ( ( rule__TupleLiteralPartCS__Group__0 ) ) )
            // InternalEOCL.g:843:2: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            {
            // InternalEOCL.g:843:2: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            // InternalEOCL.g:844:3: ( rule__TupleLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup()); 
            }
            // InternalEOCL.g:845:3: ( rule__TupleLiteralPartCS__Group__0 )
            // InternalEOCL.g:845:4: rule__TupleLiteralPartCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:854:1: entryRuleNumberLiteralExpCS : ruleNumberLiteralExpCS EOF ;
    public final void entryRuleNumberLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:855:1: ( ruleNumberLiteralExpCS EOF )
            // InternalEOCL.g:856:1: ruleNumberLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNumberLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:867:2: ( ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) )
            // InternalEOCL.g:868:2: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            {
            // InternalEOCL.g:868:2: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            // InternalEOCL.g:869:3: ( rule__NumberLiteralExpCS__SymbolAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment()); 
            }
            // InternalEOCL.g:870:3: ( rule__NumberLiteralExpCS__SymbolAssignment )
            // InternalEOCL.g:870:4: rule__NumberLiteralExpCS__SymbolAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:879:1: entryRuleStringLiteralExpCS : ruleStringLiteralExpCS EOF ;
    public final void entryRuleStringLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:880:1: ( ruleStringLiteralExpCS EOF )
            // InternalEOCL.g:881:1: ruleStringLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleStringLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:892:2: ( ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) )
            // InternalEOCL.g:893:2: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            {
            // InternalEOCL.g:893:2: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            // InternalEOCL.g:894:3: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            {
            // InternalEOCL.g:894:3: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) )
            // InternalEOCL.g:895:4: ( rule__StringLiteralExpCS__SegmentsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); 
            }
            // InternalEOCL.g:896:4: ( rule__StringLiteralExpCS__SegmentsAssignment )
            // InternalEOCL.g:896:5: rule__StringLiteralExpCS__SegmentsAssignment
            {
            pushFollow(FOLLOW_3);
            rule__StringLiteralExpCS__SegmentsAssignment();

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

            }

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

            }

            // InternalEOCL.g:899:3: ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            // InternalEOCL.g:900:4: ( rule__StringLiteralExpCS__SegmentsAssignment )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment()); 
            }
            // InternalEOCL.g:901:4: ( 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 :
            	    // InternalEOCL.g:901:5: rule__StringLiteralExpCS__SegmentsAssignment
            	    {
            	    pushFollow(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"
    // InternalEOCL.g:911:1: entryRuleBooleanLiteralExpCS : ruleBooleanLiteralExpCS EOF ;
    public final void entryRuleBooleanLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:912:1: ( ruleBooleanLiteralExpCS EOF )
            // InternalEOCL.g:913:1: ruleBooleanLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleBooleanLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:924:2: ( ( ( rule__BooleanLiteralExpCS__Alternatives ) ) )
            // InternalEOCL.g:925:2: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            {
            // InternalEOCL.g:925:2: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            // InternalEOCL.g:926:3: ( rule__BooleanLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:927:3: ( rule__BooleanLiteralExpCS__Alternatives )
            // InternalEOCL.g:927:4: rule__BooleanLiteralExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:936:1: entryRuleUnlimitedNaturalLiteralExpCS : ruleUnlimitedNaturalLiteralExpCS EOF ;
    public final void entryRuleUnlimitedNaturalLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:937:1: ( ruleUnlimitedNaturalLiteralExpCS EOF )
            // InternalEOCL.g:938:1: ruleUnlimitedNaturalLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUnlimitedNaturalLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:949:2: ( ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:950:2: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:950:2: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:951:3: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:952:3: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            // InternalEOCL.g:952:4: rule__UnlimitedNaturalLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:961:1: entryRuleInvalidLiteralExpCS : ruleInvalidLiteralExpCS EOF ;
    public final void entryRuleInvalidLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:962:1: ( ruleInvalidLiteralExpCS EOF )
            // InternalEOCL.g:963:1: ruleInvalidLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleInvalidLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:974:2: ( ( ( rule__InvalidLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:975:2: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:975:2: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:976:3: ( rule__InvalidLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:977:3: ( rule__InvalidLiteralExpCS__Group__0 )
            // InternalEOCL.g:977:4: rule__InvalidLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:986:1: entryRuleNullLiteralExpCS : ruleNullLiteralExpCS EOF ;
    public final void entryRuleNullLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:987:1: ( ruleNullLiteralExpCS EOF )
            // InternalEOCL.g:988:1: ruleNullLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNullLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:999:2: ( ( ( rule__NullLiteralExpCS__Group__0 ) ) )
            // InternalEOCL.g:1000:2: ( ( rule__NullLiteralExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1000:2: ( ( rule__NullLiteralExpCS__Group__0 ) )
            // InternalEOCL.g:1001:3: ( rule__NullLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1002:3: ( rule__NullLiteralExpCS__Group__0 )
            // InternalEOCL.g:1002:4: rule__NullLiteralExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1011:1: entryRuleTypeLiteralCS : ruleTypeLiteralCS EOF ;
    public final void entryRuleTypeLiteralCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1012:1: ( ruleTypeLiteralCS EOF )
            // InternalEOCL.g:1013:1: ruleTypeLiteralCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeLiteralCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1024:2: ( ( ( rule__TypeLiteralCS__Alternatives ) ) )
            // InternalEOCL.g:1025:2: ( ( rule__TypeLiteralCS__Alternatives ) )
            {
            // InternalEOCL.g:1025:2: ( ( rule__TypeLiteralCS__Alternatives ) )
            // InternalEOCL.g:1026:3: ( rule__TypeLiteralCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1027:3: ( rule__TypeLiteralCS__Alternatives )
            // InternalEOCL.g:1027:4: rule__TypeLiteralCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1036:1: entryRuleTypeLiteralWithMultiplicityCS : ruleTypeLiteralWithMultiplicityCS EOF ;
    public final void entryRuleTypeLiteralWithMultiplicityCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1037:1: ( ruleTypeLiteralWithMultiplicityCS EOF )
            // InternalEOCL.g:1038:1: ruleTypeLiteralWithMultiplicityCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeLiteralWithMultiplicityCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1049:2: ( ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) )
            // InternalEOCL.g:1050:2: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            {
            // InternalEOCL.g:1050:2: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            // InternalEOCL.g:1051:3: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1052:3: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            // InternalEOCL.g:1052:4: rule__TypeLiteralWithMultiplicityCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1061:1: entryRuleTypeLiteralExpCS : ruleTypeLiteralExpCS EOF ;
    public final void entryRuleTypeLiteralExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1062:1: ( ruleTypeLiteralExpCS EOF )
            // InternalEOCL.g:1063:1: ruleTypeLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeLiteralExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1074:2: ( ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) )
            // InternalEOCL.g:1075:2: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            {
            // InternalEOCL.g:1075:2: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            // InternalEOCL.g:1076:3: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment()); 
            }
            // InternalEOCL.g:1077:3: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            // InternalEOCL.g:1077:4: rule__TypeLiteralExpCS__OwnedTypeAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:1086:1: entryRuleTypeNameExpCS : ruleTypeNameExpCS EOF ;
    public final void entryRuleTypeNameExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1087:1: ( ruleTypeNameExpCS EOF )
            // InternalEOCL.g:1088:1: ruleTypeNameExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeNameExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1099:2: ( ( ( rule__TypeNameExpCS__Group__0 ) ) )
            // InternalEOCL.g:1100:2: ( ( rule__TypeNameExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1100:2: ( ( rule__TypeNameExpCS__Group__0 ) )
            // InternalEOCL.g:1101:3: ( rule__TypeNameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1102:3: ( rule__TypeNameExpCS__Group__0 )
            // InternalEOCL.g:1102:4: rule__TypeNameExpCS__Group__0
            {
            pushFollow(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 "entryRuleTypeExpCS"
    // InternalEOCL.g:1111:1: entryRuleTypeExpCS : ruleTypeExpCS EOF ;
    public final void entryRuleTypeExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1112:1: ( ruleTypeExpCS EOF )
            // InternalEOCL.g:1113:1: ruleTypeExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1124:2: ( ( ( rule__TypeExpCS__Group__0 ) ) )
            // InternalEOCL.g:1125:2: ( ( rule__TypeExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1125:2: ( ( rule__TypeExpCS__Group__0 ) )
            // InternalEOCL.g:1126:3: ( rule__TypeExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1127:3: ( rule__TypeExpCS__Group__0 )
            // InternalEOCL.g:1127:4: rule__TypeExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1136:1: entryRuleExpCS : ruleExpCS EOF ;
    public final void entryRuleExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1137:1: ( ruleExpCS EOF )
            // InternalEOCL.g:1138:1: ruleExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1149:2: ( ( ( rule__ExpCS__Alternatives ) ) )
            // InternalEOCL.g:1150:2: ( ( rule__ExpCS__Alternatives ) )
            {
            // InternalEOCL.g:1150:2: ( ( rule__ExpCS__Alternatives ) )
            // InternalEOCL.g:1151:3: ( rule__ExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1152:3: ( rule__ExpCS__Alternatives )
            // InternalEOCL.g:1152:4: rule__ExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1161:1: entryRulePrefixedLetExpCS : rulePrefixedLetExpCS EOF ;
    public final void entryRulePrefixedLetExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1162:1: ( rulePrefixedLetExpCS EOF )
            // InternalEOCL.g:1163:1: rulePrefixedLetExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrefixedLetExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1174:2: ( ( ( rule__PrefixedLetExpCS__Alternatives ) ) )
            // InternalEOCL.g:1175:2: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            {
            // InternalEOCL.g:1175:2: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            // InternalEOCL.g:1176:3: ( rule__PrefixedLetExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1177:3: ( rule__PrefixedLetExpCS__Alternatives )
            // InternalEOCL.g:1177:4: rule__PrefixedLetExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1186:1: entryRulePrefixedPrimaryExpCS : rulePrefixedPrimaryExpCS EOF ;
    public final void entryRulePrefixedPrimaryExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1187:1: ( rulePrefixedPrimaryExpCS EOF )
            // InternalEOCL.g:1188:1: rulePrefixedPrimaryExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrefixedPrimaryExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1199:2: ( ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) )
            // InternalEOCL.g:1200:2: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            {
            // InternalEOCL.g:1200:2: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            // InternalEOCL.g:1201:3: ( rule__PrefixedPrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1202:3: ( rule__PrefixedPrimaryExpCS__Alternatives )
            // InternalEOCL.g:1202:4: rule__PrefixedPrimaryExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1211:1: entryRulePrimaryExpCS : rulePrimaryExpCS EOF ;
    public final void entryRulePrimaryExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1212:1: ( rulePrimaryExpCS EOF )
            // InternalEOCL.g:1213:1: rulePrimaryExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePrimaryExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1224:2: ( ( ( rule__PrimaryExpCS__Alternatives ) ) )
            // InternalEOCL.g:1225:2: ( ( rule__PrimaryExpCS__Alternatives ) )
            {
            // InternalEOCL.g:1225:2: ( ( rule__PrimaryExpCS__Alternatives ) )
            // InternalEOCL.g:1226:3: ( rule__PrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1227:3: ( rule__PrimaryExpCS__Alternatives )
            // InternalEOCL.g:1227:4: rule__PrimaryExpCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1236:1: entryRuleNameExpCS : ruleNameExpCS EOF ;
    public final void entryRuleNameExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1237:1: ( ruleNameExpCS EOF )
            // InternalEOCL.g:1238:1: ruleNameExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNameExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1249:2: ( ( ( rule__NameExpCS__Group__0 ) ) )
            // InternalEOCL.g:1250:2: ( ( rule__NameExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1250:2: ( ( rule__NameExpCS__Group__0 ) )
            // InternalEOCL.g:1251:3: ( rule__NameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1252:3: ( rule__NameExpCS__Group__0 )
            // InternalEOCL.g:1252:4: rule__NameExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1261:1: entryRuleCurlyBracketedClauseCS : ruleCurlyBracketedClauseCS EOF ;
    public final void entryRuleCurlyBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1262:1: ( ruleCurlyBracketedClauseCS EOF )
            // InternalEOCL.g:1263:1: ruleCurlyBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCurlyBracketedClauseCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1274:2: ( ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) )
            // InternalEOCL.g:1275:2: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            {
            // InternalEOCL.g:1275:2: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            // InternalEOCL.g:1276:3: ( rule__CurlyBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1277:3: ( rule__CurlyBracketedClauseCS__Group__0 )
            // InternalEOCL.g:1277:4: rule__CurlyBracketedClauseCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1286:1: entryRuleRoundBracketedClauseCS : ruleRoundBracketedClauseCS EOF ;
    public final void entryRuleRoundBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1287:1: ( ruleRoundBracketedClauseCS EOF )
            // InternalEOCL.g:1288:1: ruleRoundBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleRoundBracketedClauseCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1299:2: ( ( ( rule__RoundBracketedClauseCS__Group__0 ) ) )
            // InternalEOCL.g:1300:2: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            {
            // InternalEOCL.g:1300:2: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            // InternalEOCL.g:1301:3: ( rule__RoundBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1302:3: ( rule__RoundBracketedClauseCS__Group__0 )
            // InternalEOCL.g:1302:4: rule__RoundBracketedClauseCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1311:1: entryRuleSquareBracketedClauseCS : ruleSquareBracketedClauseCS EOF ;
    public final void entryRuleSquareBracketedClauseCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1312:1: ( ruleSquareBracketedClauseCS EOF )
            // InternalEOCL.g:1313:1: ruleSquareBracketedClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSquareBracketedClauseCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1324:2: ( ( ( rule__SquareBracketedClauseCS__Group__0 ) ) )
            // InternalEOCL.g:1325:2: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            {
            // InternalEOCL.g:1325:2: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            // InternalEOCL.g:1326:3: ( rule__SquareBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1327:3: ( rule__SquareBracketedClauseCS__Group__0 )
            // InternalEOCL.g:1327:4: rule__SquareBracketedClauseCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1336:1: entryRuleNavigatingArgCS : ruleNavigatingArgCS EOF ;
    public final void entryRuleNavigatingArgCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1337:1: ( ruleNavigatingArgCS EOF )
            // InternalEOCL.g:1338:1: ruleNavigatingArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigatingArgCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1349:2: ( ( ( rule__NavigatingArgCS__Alternatives ) ) )
            // InternalEOCL.g:1350:2: ( ( rule__NavigatingArgCS__Alternatives ) )
            {
            // InternalEOCL.g:1350:2: ( ( rule__NavigatingArgCS__Alternatives ) )
            // InternalEOCL.g:1351:3: ( rule__NavigatingArgCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1352:3: ( rule__NavigatingArgCS__Alternatives )
            // InternalEOCL.g:1352:4: rule__NavigatingArgCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1361:1: entryRuleNavigatingBarArgCS : ruleNavigatingBarArgCS EOF ;
    public final void entryRuleNavigatingBarArgCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1362:1: ( ruleNavigatingBarArgCS EOF )
            // InternalEOCL.g:1363:1: ruleNavigatingBarArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigatingBarArgCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1374:2: ( ( ( rule__NavigatingBarArgCS__Group__0 ) ) )
            // InternalEOCL.g:1375:2: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            {
            // InternalEOCL.g:1375:2: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            // InternalEOCL.g:1376:3: ( rule__NavigatingBarArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1377:3: ( rule__NavigatingBarArgCS__Group__0 )
            // InternalEOCL.g:1377:4: rule__NavigatingBarArgCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1386:1: entryRuleNavigatingCommaArgCS : ruleNavigatingCommaArgCS EOF ;
    public final void entryRuleNavigatingCommaArgCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1387:1: ( ruleNavigatingCommaArgCS EOF )
            // InternalEOCL.g:1388:1: ruleNavigatingCommaArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigatingCommaArgCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1399:2: ( ( ( rule__NavigatingCommaArgCS__Group__0 ) ) )
            // InternalEOCL.g:1400:2: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            {
            // InternalEOCL.g:1400:2: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            // InternalEOCL.g:1401:3: ( rule__NavigatingCommaArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1402:3: ( rule__NavigatingCommaArgCS__Group__0 )
            // InternalEOCL.g:1402:4: rule__NavigatingCommaArgCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1411:1: entryRuleNavigatingSemiArgCS : ruleNavigatingSemiArgCS EOF ;
    public final void entryRuleNavigatingSemiArgCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1412:1: ( ruleNavigatingSemiArgCS EOF )
            // InternalEOCL.g:1413:1: ruleNavigatingSemiArgCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigatingSemiArgCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1424:2: ( ( ( rule__NavigatingSemiArgCS__Group__0 ) ) )
            // InternalEOCL.g:1425:2: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            {
            // InternalEOCL.g:1425:2: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            // InternalEOCL.g:1426:3: ( rule__NavigatingSemiArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1427:3: ( rule__NavigatingSemiArgCS__Group__0 )
            // InternalEOCL.g:1427:4: rule__NavigatingSemiArgCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1436:1: entryRuleNavigatingArgExpCS : ruleNavigatingArgExpCS EOF ;
    public final void entryRuleNavigatingArgExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1437:1: ( ruleNavigatingArgExpCS EOF )
            // InternalEOCL.g:1438:1: ruleNavigatingArgExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigatingArgExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1449:2: ( ( ruleExpCS ) )
            // InternalEOCL.g:1450:2: ( ruleExpCS )
            {
            // InternalEOCL.g:1450:2: ( ruleExpCS )
            // InternalEOCL.g:1451:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall()); 
            }
            pushFollow(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 "entryRuleIfExpCS"
    // InternalEOCL.g:1461:1: entryRuleIfExpCS : ruleIfExpCS EOF ;
    public final void entryRuleIfExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1462:1: ( ruleIfExpCS EOF )
            // InternalEOCL.g:1463:1: ruleIfExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIfExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1474:2: ( ( ( rule__IfExpCS__Group__0 ) ) )
            // InternalEOCL.g:1475:2: ( ( rule__IfExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1475:2: ( ( rule__IfExpCS__Group__0 ) )
            // InternalEOCL.g:1476:3: ( rule__IfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1477:3: ( rule__IfExpCS__Group__0 )
            // InternalEOCL.g:1477:4: rule__IfExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1486:1: entryRuleElseIfThenExpCS : ruleElseIfThenExpCS EOF ;
    public final void entryRuleElseIfThenExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1487:1: ( ruleElseIfThenExpCS EOF )
            // InternalEOCL.g:1488:1: ruleElseIfThenExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleElseIfThenExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1499:2: ( ( ( rule__ElseIfThenExpCS__Group__0 ) ) )
            // InternalEOCL.g:1500:2: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1500:2: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            // InternalEOCL.g:1501:3: ( rule__ElseIfThenExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1502:3: ( rule__ElseIfThenExpCS__Group__0 )
            // InternalEOCL.g:1502:4: rule__ElseIfThenExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1511:1: entryRuleLetExpCS : ruleLetExpCS EOF ;
    public final void entryRuleLetExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1512:1: ( ruleLetExpCS EOF )
            // InternalEOCL.g:1513:1: ruleLetExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLetExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1524:2: ( ( ( rule__LetExpCS__Group__0 ) ) )
            // InternalEOCL.g:1525:2: ( ( rule__LetExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1525:2: ( ( rule__LetExpCS__Group__0 ) )
            // InternalEOCL.g:1526:3: ( rule__LetExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1527:3: ( rule__LetExpCS__Group__0 )
            // InternalEOCL.g:1527:4: rule__LetExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1536:1: entryRuleLetVariableCS : ruleLetVariableCS EOF ;
    public final void entryRuleLetVariableCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1537:1: ( ruleLetVariableCS EOF )
            // InternalEOCL.g:1538:1: ruleLetVariableCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLetVariableCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1549:2: ( ( ( rule__LetVariableCS__Group__0 ) ) )
            // InternalEOCL.g:1550:2: ( ( rule__LetVariableCS__Group__0 ) )
            {
            // InternalEOCL.g:1550:2: ( ( rule__LetVariableCS__Group__0 ) )
            // InternalEOCL.g:1551:3: ( rule__LetVariableCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1552:3: ( rule__LetVariableCS__Group__0 )
            // InternalEOCL.g:1552:4: rule__LetVariableCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1561:1: entryRuleNestedExpCS : ruleNestedExpCS EOF ;
    public final void entryRuleNestedExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1562:1: ( ruleNestedExpCS EOF )
            // InternalEOCL.g:1563:1: ruleNestedExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNestedExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1574:2: ( ( ( rule__NestedExpCS__Group__0 ) ) )
            // InternalEOCL.g:1575:2: ( ( rule__NestedExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1575:2: ( ( rule__NestedExpCS__Group__0 ) )
            // InternalEOCL.g:1576:3: ( rule__NestedExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1577:3: ( rule__NestedExpCS__Group__0 )
            // InternalEOCL.g:1577:4: rule__NestedExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1586:1: entryRuleSelfExpCS : ruleSelfExpCS EOF ;
    public final void entryRuleSelfExpCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1587:1: ( ruleSelfExpCS EOF )
            // InternalEOCL.g:1588:1: ruleSelfExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSelfExpCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1599:2: ( ( ( rule__SelfExpCS__Group__0 ) ) )
            // InternalEOCL.g:1600:2: ( ( rule__SelfExpCS__Group__0 ) )
            {
            // InternalEOCL.g:1600:2: ( ( rule__SelfExpCS__Group__0 ) )
            // InternalEOCL.g:1601:3: ( rule__SelfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1602:3: ( rule__SelfExpCS__Group__0 )
            // InternalEOCL.g:1602:4: rule__SelfExpCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1611:1: entryRuleMultiplicityBoundsCS : ruleMultiplicityBoundsCS EOF ;
    public final void entryRuleMultiplicityBoundsCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1612:1: ( ruleMultiplicityBoundsCS EOF )
            // InternalEOCL.g:1613:1: ruleMultiplicityBoundsCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMultiplicityBoundsCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1624:2: ( ( ( rule__MultiplicityBoundsCS__Group__0 ) ) )
            // InternalEOCL.g:1625:2: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            {
            // InternalEOCL.g:1625:2: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            // InternalEOCL.g:1626:3: ( rule__MultiplicityBoundsCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1627:3: ( rule__MultiplicityBoundsCS__Group__0 )
            // InternalEOCL.g:1627:4: rule__MultiplicityBoundsCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1636:1: entryRuleMultiplicityCS : ruleMultiplicityCS EOF ;
    public final void entryRuleMultiplicityCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1637:1: ( ruleMultiplicityCS EOF )
            // InternalEOCL.g:1638:1: ruleMultiplicityCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMultiplicityCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1649:2: ( ( ( rule__MultiplicityCS__Group__0 ) ) )
            // InternalEOCL.g:1650:2: ( ( rule__MultiplicityCS__Group__0 ) )
            {
            // InternalEOCL.g:1650:2: ( ( rule__MultiplicityCS__Group__0 ) )
            // InternalEOCL.g:1651:3: ( rule__MultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1652:3: ( rule__MultiplicityCS__Group__0 )
            // InternalEOCL.g:1652:4: rule__MultiplicityCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1661:1: entryRuleMultiplicityStringCS : ruleMultiplicityStringCS EOF ;
    public final void entryRuleMultiplicityStringCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1662:1: ( ruleMultiplicityStringCS EOF )
            // InternalEOCL.g:1663:1: ruleMultiplicityStringCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMultiplicityStringCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1674:2: ( ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) )
            // InternalEOCL.g:1675:2: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            {
            // InternalEOCL.g:1675:2: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            // InternalEOCL.g:1676:3: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment()); 
            }
            // InternalEOCL.g:1677:3: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            // InternalEOCL.g:1677:4: rule__MultiplicityStringCS__StringBoundsAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:1686:1: entryRulePathNameCS : rulePathNameCS EOF ;
    public final void entryRulePathNameCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1687:1: ( rulePathNameCS EOF )
            // InternalEOCL.g:1688:1: rulePathNameCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePathNameCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1699:2: ( ( ( rule__PathNameCS__Group__0 ) ) )
            // InternalEOCL.g:1700:2: ( ( rule__PathNameCS__Group__0 ) )
            {
            // InternalEOCL.g:1700:2: ( ( rule__PathNameCS__Group__0 ) )
            // InternalEOCL.g:1701:3: ( rule__PathNameCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1702:3: ( rule__PathNameCS__Group__0 )
            // InternalEOCL.g:1702:4: rule__PathNameCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1711:1: entryRuleFirstPathElementCS : ruleFirstPathElementCS EOF ;
    public final void entryRuleFirstPathElementCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1712:1: ( ruleFirstPathElementCS EOF )
            // InternalEOCL.g:1713:1: ruleFirstPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleFirstPathElementCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1724:2: ( ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) )
            // InternalEOCL.g:1725:2: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            {
            // InternalEOCL.g:1725:2: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            // InternalEOCL.g:1726:3: ( rule__FirstPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment()); 
            }
            // InternalEOCL.g:1727:3: ( rule__FirstPathElementCS__ReferredElementAssignment )
            // InternalEOCL.g:1727:4: rule__FirstPathElementCS__ReferredElementAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:1736:1: entryRuleNextPathElementCS : ruleNextPathElementCS EOF ;
    public final void entryRuleNextPathElementCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1737:1: ( ruleNextPathElementCS EOF )
            // InternalEOCL.g:1738:1: ruleNextPathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNextPathElementCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1749:2: ( ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) )
            // InternalEOCL.g:1750:2: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            {
            // InternalEOCL.g:1750:2: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            // InternalEOCL.g:1751:3: ( rule__NextPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment()); 
            }
            // InternalEOCL.g:1752:3: ( rule__NextPathElementCS__ReferredElementAssignment )
            // InternalEOCL.g:1752:4: rule__NextPathElementCS__ReferredElementAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:1761:1: entryRuleTemplateBindingCS : ruleTemplateBindingCS EOF ;
    public final void entryRuleTemplateBindingCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1762:1: ( ruleTemplateBindingCS EOF )
            // InternalEOCL.g:1763:1: ruleTemplateBindingCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTemplateBindingCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1774:2: ( ( ( rule__TemplateBindingCS__Group__0 ) ) )
            // InternalEOCL.g:1775:2: ( ( rule__TemplateBindingCS__Group__0 ) )
            {
            // InternalEOCL.g:1775:2: ( ( rule__TemplateBindingCS__Group__0 ) )
            // InternalEOCL.g:1776:3: ( rule__TemplateBindingCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1777:3: ( rule__TemplateBindingCS__Group__0 )
            // InternalEOCL.g:1777:4: rule__TemplateBindingCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1786:1: entryRuleTemplateParameterSubstitutionCS : ruleTemplateParameterSubstitutionCS EOF ;
    public final void entryRuleTemplateParameterSubstitutionCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1787:1: ( ruleTemplateParameterSubstitutionCS EOF )
            // InternalEOCL.g:1788:1: ruleTemplateParameterSubstitutionCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTemplateParameterSubstitutionCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1799:2: ( ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) )
            // InternalEOCL.g:1800:2: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            {
            // InternalEOCL.g:1800:2: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            // InternalEOCL.g:1801:3: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment()); 
            }
            // InternalEOCL.g:1802:3: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            // InternalEOCL.g:1802:4: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment
            {
            pushFollow(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"
    // InternalEOCL.g:1811:1: entryRuleTypeParameterCS : ruleTypeParameterCS EOF ;
    public final void entryRuleTypeParameterCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1812:1: ( ruleTypeParameterCS EOF )
            // InternalEOCL.g:1813:1: ruleTypeParameterCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeParameterCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1824:2: ( ( ( rule__TypeParameterCS__Group__0 ) ) )
            // InternalEOCL.g:1825:2: ( ( rule__TypeParameterCS__Group__0 ) )
            {
            // InternalEOCL.g:1825:2: ( ( rule__TypeParameterCS__Group__0 ) )
            // InternalEOCL.g:1826:3: ( rule__TypeParameterCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1827:3: ( rule__TypeParameterCS__Group__0 )
            // InternalEOCL.g:1827:4: rule__TypeParameterCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1836:1: entryRuleTypeRefCS : ruleTypeRefCS EOF ;
    public final void entryRuleTypeRefCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1837:1: ( ruleTypeRefCS EOF )
            // InternalEOCL.g:1838:1: ruleTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeRefCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypeRefCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1849:2: ( ( ( rule__TypeRefCS__Alternatives ) ) )
            // InternalEOCL.g:1850:2: ( ( rule__TypeRefCS__Alternatives ) )
            {
            // InternalEOCL.g:1850:2: ( ( rule__TypeRefCS__Alternatives ) )
            // InternalEOCL.g:1851:3: ( rule__TypeRefCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeRefCSAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1852:3: ( rule__TypeRefCS__Alternatives )
            // InternalEOCL.g:1852:4: rule__TypeRefCS__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1861:1: entryRuleTypedRefCS : ruleTypedRefCS EOF ;
    public final void entryRuleTypedRefCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1862:1: ( ruleTypedRefCS EOF )
            // InternalEOCL.g:1863:1: ruleTypedRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedRefCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypedRefCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1874:2: ( ( ruleTypedTypeRefCS ) )
            // InternalEOCL.g:1875:2: ( ruleTypedTypeRefCS )
            {
            // InternalEOCL.g:1875:2: ( ruleTypedTypeRefCS )
            // InternalEOCL.g:1876:3: ruleTypedTypeRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:1886:1: entryRuleTypedTypeRefCS : ruleTypedTypeRefCS EOF ;
    public final void entryRuleTypedTypeRefCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1887:1: ( ruleTypedTypeRefCS EOF )
            // InternalEOCL.g:1888:1: ruleTypedTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleTypedTypeRefCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1899:2: ( ( ( rule__TypedTypeRefCS__Group__0 ) ) )
            // InternalEOCL.g:1900:2: ( ( rule__TypedTypeRefCS__Group__0 ) )
            {
            // InternalEOCL.g:1900:2: ( ( rule__TypedTypeRefCS__Group__0 ) )
            // InternalEOCL.g:1901:3: ( rule__TypedTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1902:3: ( rule__TypedTypeRefCS__Group__0 )
            // InternalEOCL.g:1902:4: rule__TypedTypeRefCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1911:1: entryRuleWildcardTypeRefCS : ruleWildcardTypeRefCS EOF ;
    public final void entryRuleWildcardTypeRefCS() throws RecognitionException {
        try {
            // InternalEOCL.g:1912:1: ( ruleWildcardTypeRefCS EOF )
            // InternalEOCL.g:1913:1: ruleWildcardTypeRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleWildcardTypeRefCS();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1924:2: ( ( ( rule__WildcardTypeRefCS__Group__0 ) ) )
            // InternalEOCL.g:1925:2: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            {
            // InternalEOCL.g:1925:2: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            // InternalEOCL.g:1926:3: ( rule__WildcardTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup()); 
            }
            // InternalEOCL.g:1927:3: ( rule__WildcardTypeRefCS__Group__0 )
            // InternalEOCL.g:1927:4: rule__WildcardTypeRefCS__Group__0
            {
            pushFollow(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"
    // InternalEOCL.g:1936:1: entryRuleID : ruleID EOF ;
    public final void entryRuleID() throws RecognitionException {
        try {
            // InternalEOCL.g:1937:1: ( ruleID EOF )
            // InternalEOCL.g:1938:1: ruleID EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIDRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleID();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1949:2: ( ( ( rule__ID__Alternatives ) ) )
            // InternalEOCL.g:1950:2: ( ( rule__ID__Alternatives ) )
            {
            // InternalEOCL.g:1950:2: ( ( rule__ID__Alternatives ) )
            // InternalEOCL.g:1951:3: ( rule__ID__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIDAccess().getAlternatives()); 
            }
            // InternalEOCL.g:1952:3: ( rule__ID__Alternatives )
            // InternalEOCL.g:1952:4: rule__ID__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:1961:1: entryRuleIdentifier : ruleIdentifier EOF ;
    public final void entryRuleIdentifier() throws RecognitionException {
        try {
            // InternalEOCL.g:1962:1: ( ruleIdentifier EOF )
            // InternalEOCL.g:1963:1: ruleIdentifier EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdentifierRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIdentifier();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1974:2: ( ( ruleID ) )
            // InternalEOCL.g:1975:2: ( ruleID )
            {
            // InternalEOCL.g:1975:2: ( ruleID )
            // InternalEOCL.g:1976:3: ruleID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdentifierAccess().getIDParserRuleCall()); 
            }
            pushFollow(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"
    // InternalEOCL.g:1986:1: entryRuleLOWER : ruleLOWER EOF ;
    public final void entryRuleLOWER() throws RecognitionException {
        try {
            // InternalEOCL.g:1987:1: ( ruleLOWER EOF )
            // InternalEOCL.g:1988:1: ruleLOWER EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLOWERRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLOWER();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:1999:2: ( ( RULE_INT ) )
            // InternalEOCL.g:2000:2: ( RULE_INT )
            {
            // InternalEOCL.g:2000:2: ( RULE_INT )
            // InternalEOCL.g:2001:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLOWERAccess().getINTTerminalRuleCall()); 
            }
            match(input,RULE_INT,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"
    // InternalEOCL.g:2011:1: entryRuleNUMBER_LITERAL : ruleNUMBER_LITERAL EOF ;
    public final void entryRuleNUMBER_LITERAL() throws RecognitionException {
        try {
            // InternalEOCL.g:2012:1: ( ruleNUMBER_LITERAL EOF )
            // InternalEOCL.g:2013:1: ruleNUMBER_LITERAL EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNUMBER_LITERALRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNUMBER_LITERAL();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2024:2: ( ( RULE_INT ) )
            // InternalEOCL.g:2025:2: ( RULE_INT )
            {
            // InternalEOCL.g:2025:2: ( RULE_INT )
            // InternalEOCL.g:2026:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall()); 
            }
            match(input,RULE_INT,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"
    // InternalEOCL.g:2036:1: entryRuleStringLiteral : ruleStringLiteral EOF ;
    public final void entryRuleStringLiteral() throws RecognitionException {
        try {
            // InternalEOCL.g:2037:1: ( ruleStringLiteral EOF )
            // InternalEOCL.g:2038:1: ruleStringLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleStringLiteral();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2049:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalEOCL.g:2050:2: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalEOCL.g:2050:2: ( RULE_SINGLE_QUOTED_STRING )
            // InternalEOCL.g:2051:3: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); 
            }
            match(input,RULE_SINGLE_QUOTED_STRING,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"
    // InternalEOCL.g:2061:1: entryRuleUPPER : ruleUPPER EOF ;
    public final void entryRuleUPPER() throws RecognitionException {
        try {
            // InternalEOCL.g:2062:1: ( ruleUPPER EOF )
            // InternalEOCL.g:2063:1: ruleUPPER EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUPPERRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleUPPER();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2074:2: ( ( ( rule__UPPER__Alternatives ) ) )
            // InternalEOCL.g:2075:2: ( ( rule__UPPER__Alternatives ) )
            {
            // InternalEOCL.g:2075:2: ( ( rule__UPPER__Alternatives ) )
            // InternalEOCL.g:2076:3: ( rule__UPPER__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUPPERAccess().getAlternatives()); 
            }
            // InternalEOCL.g:2077:3: ( rule__UPPER__Alternatives )
            // InternalEOCL.g:2077:4: rule__UPPER__Alternatives
            {
            pushFollow(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"
    // InternalEOCL.g:2086:1: entryRuleURI : ruleURI EOF ;
    public final void entryRuleURI() throws RecognitionException {
        try {
            // InternalEOCL.g:2087:1: ( ruleURI EOF )
            // InternalEOCL.g:2088:1: ruleURI EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleURI();

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

            }

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2099:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalEOCL.g:2100:2: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalEOCL.g:2100:2: ( RULE_SINGLE_QUOTED_STRING )
            // InternalEOCL.g:2101:3: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall()); 
            }
            match(input,RULE_SINGLE_QUOTED_STRING,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"
    // InternalEOCL.g:2110:1: rule__EssentialOCLUnaryOperatorName__Alternatives : ( ( '-' ) | ( 'not' ) );
    public final void rule__EssentialOCLUnaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2114:1: ( ( '-' ) | ( 'not' ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

            if ( (LA2_0==16) ) {
                alt2=1;
            }
            else if ( (LA2_0==17) ) {
                alt2=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 2, 0, input);

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // InternalEOCL.g:2115:2: ( '-' )
                    {
                    // InternalEOCL.g:2115:2: ( '-' )
                    // InternalEOCL.g:2116:3: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); 
                    }
                    match(input,16,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2121:2: ( 'not' )
                    {
                    // InternalEOCL.g:2121:2: ( 'not' )
                    // InternalEOCL.g:2122:3: 'not'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); 
                    }
                    match(input,17,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EssentialOCLInfixOperatorName__Alternatives"
    // InternalEOCL.g:2131:1: rule__EssentialOCLInfixOperatorName__Alternatives : ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'or' ) | ( 'xor' ) | ( 'implies' ) );
    public final void rule__EssentialOCLInfixOperatorName__Alternatives() throws RecognitionException {

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

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // InternalEOCL.g:2136:2: ( '*' )
                    {
                    // InternalEOCL.g:2136:2: ( '*' )
                    // InternalEOCL.g:2137:3: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); 
                    }
                    match(input,18,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2142:2: ( '/' )
                    {
                    // InternalEOCL.g:2142:2: ( '/' )
                    // InternalEOCL.g:2143:3: '/'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); 
                    }
                    match(input,19,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2148:2: ( '+' )
                    {
                    // InternalEOCL.g:2148:2: ( '+' )
                    // InternalEOCL.g:2149:3: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); 
                    }
                    match(input,20,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2154:2: ( '-' )
                    {
                    // InternalEOCL.g:2154:2: ( '-' )
                    // InternalEOCL.g:2155:3: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); 
                    }
                    match(input,16,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2160:2: ( '>' )
                    {
                    // InternalEOCL.g:2160:2: ( '>' )
                    // InternalEOCL.g:2161:3: '>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); 
                    }
                    match(input,21,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEOCL.g:2166:2: ( '<' )
                    {
                    // InternalEOCL.g:2166:2: ( '<' )
                    // InternalEOCL.g:2167:3: '<'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); 
                    }
                    match(input,22,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5()); 
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalEOCL.g:2172:2: ( '>=' )
                    {
                    // InternalEOCL.g:2172:2: ( '>=' )
                    // InternalEOCL.g:2173:3: '>='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); 
                    }
                    match(input,23,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6()); 
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalEOCL.g:2178:2: ( '<=' )
                    {
                    // InternalEOCL.g:2178:2: ( '<=' )
                    // InternalEOCL.g:2179:3: '<='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); 
                    }
                    match(input,24,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7()); 
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalEOCL.g:2184:2: ( '=' )
                    {
                    // InternalEOCL.g:2184:2: ( '=' )
                    // InternalEOCL.g:2185:3: '='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); 
                    }
                    match(input,25,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8()); 
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalEOCL.g:2190:2: ( '<>' )
                    {
                    // InternalEOCL.g:2190:2: ( '<>' )
                    // InternalEOCL.g:2191:3: '<>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); 
                    }
                    match(input,26,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9()); 
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalEOCL.g:2196:2: ( 'and' )
                    {
                    // InternalEOCL.g:2196:2: ( 'and' )
                    // InternalEOCL.g:2197:3: 'and'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); 
                    }
                    match(input,27,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10()); 
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalEOCL.g:2202:2: ( 'or' )
                    {
                    // InternalEOCL.g:2202:2: ( 'or' )
                    // InternalEOCL.g:2203:3: 'or'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_11()); 
                    }
                    match(input,28,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_11()); 
                    }

                    }


                    }
                    break;
                case 13 :
                    // InternalEOCL.g:2208:2: ( 'xor' )
                    {
                    // InternalEOCL.g:2208:2: ( 'xor' )
                    // InternalEOCL.g:2209:3: 'xor'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_12()); 
                    }
                    match(input,29,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_12()); 
                    }

                    }


                    }
                    break;
                case 14 :
                    // InternalEOCL.g:2214:2: ( 'implies' )
                    {
                    // InternalEOCL.g:2214:2: ( 'implies' )
                    // InternalEOCL.g:2215:3: 'implies'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_13()); 
                    }
                    match(input,30,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_13()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


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

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2228:1: ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) )
            int alt4=4;
            switch ( input.LA(1) ) {
            case 31:
                {
                alt4=1;
                }
                break;
            case 32:
                {
                alt4=2;
                }
                break;
            case 33:
                {
                alt4=3;
                }
                break;
            case 34:
                {
                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 :
                    // InternalEOCL.g:2229:2: ( '.' )
                    {
                    // InternalEOCL.g:2229:2: ( '.' )
                    // InternalEOCL.g:2230:3: '.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); 
                    }
                    match(input,31,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2235:2: ( '->' )
                    {
                    // InternalEOCL.g:2235:2: ( '->' )
                    // InternalEOCL.g:2236:3: '->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); 
                    }
                    match(input,32,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2241:2: ( '?.' )
                    {
                    // InternalEOCL.g:2241:2: ( '?.' )
                    // InternalEOCL.g:2242:3: '?.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); 
                    }
                    match(input,33,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2247:2: ( '?->' )
                    {
                    // InternalEOCL.g:2247:2: ( '?->' )
                    // InternalEOCL.g:2248:3: '?->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3()); 
                    }
                    match(input,34,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"
    // InternalEOCL.g:2257:1: rule__BinaryOperatorName__Alternatives : ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) );
    public final void rule__BinaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2261:1: ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==16||(LA5_0>=18 && LA5_0<=30)) ) {
                alt5=1;
            }
            else if ( ((LA5_0>=31 && LA5_0<=34)) ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // InternalEOCL.g:2262:2: ( ruleInfixOperatorName )
                    {
                    // InternalEOCL.g:2262:2: ( ruleInfixOperatorName )
                    // InternalEOCL.g:2263:3: ruleInfixOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleInfixOperatorName();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2268:2: ( ruleNavigationOperatorName )
                    {
                    // InternalEOCL.g:2268:2: ( ruleNavigationOperatorName )
                    // InternalEOCL.g:2269:3: ruleNavigationOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2278:1: rule__EssentialOCLUnreservedName__Alternatives : ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) );
    public final void rule__EssentialOCLUnreservedName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2282: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 45:
            case 46:
            case 47:
            case 48:
            case 49:
                {
                alt6=2;
                }
                break;
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
                {
                alt6=3;
                }
                break;
            case 35:
                {
                alt6=4;
                }
                break;
            case 36:
                {
                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 :
                    // InternalEOCL.g:2283:2: ( ruleUnrestrictedName )
                    {
                    // InternalEOCL.g:2283:2: ( ruleUnrestrictedName )
                    // InternalEOCL.g:2284:3: ruleUnrestrictedName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleUnrestrictedName();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2289:2: ( ruleCollectionTypeIdentifier )
                    {
                    // InternalEOCL.g:2289:2: ( ruleCollectionTypeIdentifier )
                    // InternalEOCL.g:2290:3: ruleCollectionTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectionTypeIdentifier();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2295:2: ( rulePrimitiveTypeIdentifier )
                    {
                    // InternalEOCL.g:2295:2: ( rulePrimitiveTypeIdentifier )
                    // InternalEOCL.g:2296:3: rulePrimitiveTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    rulePrimitiveTypeIdentifier();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2301:2: ( 'Map' )
                    {
                    // InternalEOCL.g:2301:2: ( 'Map' )
                    // InternalEOCL.g:2302:3: 'Map'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); 
                    }
                    match(input,35,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2307:2: ( 'Tuple' )
                    {
                    // InternalEOCL.g:2307:2: ( 'Tuple' )
                    // InternalEOCL.g:2308:3: 'Tuple'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4()); 
                    }
                    match(input,36,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"
    // InternalEOCL.g:2317: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 {
            // InternalEOCL.g:2321: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 :
                    // InternalEOCL.g:2322:2: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    {
                    // InternalEOCL.g:2322:2: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    // InternalEOCL.g:2323:3: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0()); 
                    }
                    // InternalEOCL.g:2324:3: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    // InternalEOCL.g:2324:4: rule__URIFirstPathElementCS__ReferredElementAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__URIFirstPathElementCS__ReferredElementAssignment_0();

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

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2328:2: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    {
                    // InternalEOCL.g:2328:2: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    // InternalEOCL.g:2329:3: ( rule__URIFirstPathElementCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1()); 
                    }
                    // InternalEOCL.g:2330:3: ( rule__URIFirstPathElementCS__Group_1__0 )
                    // InternalEOCL.g:2330:4: rule__URIFirstPathElementCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:2338:1: rule__PrimitiveTypeIdentifier__Alternatives : ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) );
    public final void rule__PrimitiveTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2342:1: ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) )
            int alt8=8;
            switch ( input.LA(1) ) {
            case 37:
                {
                alt8=1;
                }
                break;
            case 38:
                {
                alt8=2;
                }
                break;
            case 39:
                {
                alt8=3;
                }
                break;
            case 40:
                {
                alt8=4;
                }
                break;
            case 41:
                {
                alt8=5;
                }
                break;
            case 42:
                {
                alt8=6;
                }
                break;
            case 43:
                {
                alt8=7;
                }
                break;
            case 44:
                {
                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 :
                    // InternalEOCL.g:2343:2: ( 'Boolean' )
                    {
                    // InternalEOCL.g:2343:2: ( 'Boolean' )
                    // InternalEOCL.g:2344:3: 'Boolean'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); 
                    }
                    match(input,37,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2349:2: ( 'Integer' )
                    {
                    // InternalEOCL.g:2349:2: ( 'Integer' )
                    // InternalEOCL.g:2350:3: 'Integer'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); 
                    }
                    match(input,38,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2355:2: ( 'Real' )
                    {
                    // InternalEOCL.g:2355:2: ( 'Real' )
                    // InternalEOCL.g:2356:3: 'Real'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); 
                    }
                    match(input,39,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2361:2: ( 'String' )
                    {
                    // InternalEOCL.g:2361:2: ( 'String' )
                    // InternalEOCL.g:2362:3: 'String'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); 
                    }
                    match(input,40,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2367:2: ( 'UnlimitedNatural' )
                    {
                    // InternalEOCL.g:2367:2: ( 'UnlimitedNatural' )
                    // InternalEOCL.g:2368:3: 'UnlimitedNatural'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); 
                    }
                    match(input,41,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4()); 
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalEOCL.g:2373:2: ( 'OclAny' )
                    {
                    // InternalEOCL.g:2373:2: ( 'OclAny' )
                    // InternalEOCL.g:2374:3: 'OclAny'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); 
                    }
                    match(input,42,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5()); 
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalEOCL.g:2379:2: ( 'OclInvalid' )
                    {
                    // InternalEOCL.g:2379:2: ( 'OclInvalid' )
                    // InternalEOCL.g:2380:3: 'OclInvalid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); 
                    }
                    match(input,43,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6()); 
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalEOCL.g:2385:2: ( 'OclVoid' )
                    {
                    // InternalEOCL.g:2385:2: ( 'OclVoid' )
                    // InternalEOCL.g:2386:3: 'OclVoid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7()); 
                    }
                    match(input,44,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"
    // InternalEOCL.g:2395:1: rule__CollectionTypeIdentifier__Alternatives : ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) );
    public final void rule__CollectionTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2399:1: ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) )
            int alt9=5;
            switch ( input.LA(1) ) {
            case 45:
                {
                alt9=1;
                }
                break;
            case 46:
                {
                alt9=2;
                }
                break;
            case 47:
                {
                alt9=3;
                }
                break;
            case 48:
                {
                alt9=4;
                }
                break;
            case 49:
                {
                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 :
                    // InternalEOCL.g:2400:2: ( 'Set' )
                    {
                    // InternalEOCL.g:2400:2: ( 'Set' )
                    // InternalEOCL.g:2401:3: 'Set'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); 
                    }
                    match(input,45,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2406:2: ( 'Bag' )
                    {
                    // InternalEOCL.g:2406:2: ( 'Bag' )
                    // InternalEOCL.g:2407:3: 'Bag'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); 
                    }
                    match(input,46,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2412:2: ( 'Sequence' )
                    {
                    // InternalEOCL.g:2412:2: ( 'Sequence' )
                    // InternalEOCL.g:2413:3: 'Sequence'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); 
                    }
                    match(input,47,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2()); 
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2418:2: ( 'Collection' )
                    {
                    // InternalEOCL.g:2418:2: ( 'Collection' )
                    // InternalEOCL.g:2419:3: 'Collection'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); 
                    }
                    match(input,48,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3()); 
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2424:2: ( 'OrderedSet' )
                    {
                    // InternalEOCL.g:2424:2: ( 'OrderedSet' )
                    // InternalEOCL.g:2425:3: 'OrderedSet'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4()); 
                    }
                    match(input,49,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"
    // InternalEOCL.g:2434: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 {
            // InternalEOCL.g:2438: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 35:
            case 36:
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 53:
            case 61:
            case 63:
            case 64:
            case 69:
            case 74:
            case 75:
            case 79:
            case 80:
                {
                alt10=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA10_2 = input.LA(2);

                if ( (LA10_2==56) ) {
                    alt10=2;
                }
                else if ( (LA10_2==EOF||LA10_2==16||(LA10_2>=18 && LA10_2<=34)||LA10_2==53||LA10_2==55||(LA10_2>=57 && LA10_2<=59)||LA10_2==66||LA10_2==76||LA10_2==81) ) {
                    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==56) ) {
                    alt10=2;
                }
                else if ( (LA10_3==EOF||LA10_3==16||(LA10_3>=18 && LA10_3<=34)||LA10_3==53||LA10_3==55||(LA10_3>=57 && LA10_3<=59)||LA10_3==66||LA10_3==76||LA10_3==81) ) {
                    alt10=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 10, 3, input);

                    throw nvae;
                }
                }
                break;
            case 56:
                {
                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 :
                    // InternalEOCL.g:2439:2: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    {
                    // InternalEOCL.g:2439:2: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    // InternalEOCL.g:2440:3: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0()); 
                    }
                    // InternalEOCL.g:2441:3: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    // InternalEOCL.g:2441:4: rule__CollectionLiteralPartCS__Group_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2445:2: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    {
                    // InternalEOCL.g:2445:2: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    // InternalEOCL.g:2446:3: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1()); 
                    }
                    // InternalEOCL.g:2447:3: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    // InternalEOCL.g:2447:4: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1
                    {
                    pushFollow(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__OwnedInitExpressionAlternatives_2_0"
    // InternalEOCL.g:2455:1: rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2459:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt11=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 16:
            case 17:
            case 18:
            case 35:
            case 36:
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 53:
            case 61:
            case 63:
            case 64:
            case 69:
            case 74:
            case 75:
            case 79:
            case 80:
                {
                alt11=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA11_2 = input.LA(2);

                if ( (LA11_2==EOF||LA11_2==16||(LA11_2>=18 && LA11_2<=34)||LA11_2==53||LA11_2==55||(LA11_2>=57 && LA11_2<=58)||LA11_2==66||LA11_2==76||LA11_2==81) ) {
                    alt11=1;
                }
                else if ( (LA11_2==56) ) {
                    alt11=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 11, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA11_3 = input.LA(2);

                if ( (LA11_3==56) ) {
                    alt11=2;
                }
                else if ( (LA11_3==EOF||LA11_3==16||(LA11_3>=18 && LA11_3<=34)||LA11_3==53||LA11_3==55||(LA11_3>=57 && LA11_3<=58)||LA11_3==66||LA11_3==76||LA11_3==81) ) {
                    alt11=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 11, 3, input);

                    throw nvae;
                }
                }
                break;
            case 56:
                {
                alt11=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }

            switch (alt11) {
                case 1 :
                    // InternalEOCL.g:2460:2: ( ruleExpCS )
                    {
                    // InternalEOCL.g:2460:2: ( ruleExpCS )
                    // InternalEOCL.g:2461:3: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2466:2: ( rulePatternExpCS )
                    {
                    // InternalEOCL.g:2466:2: ( rulePatternExpCS )
                    // InternalEOCL.g:2467:3: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_2_0_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    rulePatternExpCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PrimitiveLiteralExpCS__Alternatives"
    // InternalEOCL.g:2476:1: rule__PrimitiveLiteralExpCS__Alternatives : ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) );
    public final void rule__PrimitiveLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2480:1: ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) )
            int alt12=6;
            switch ( input.LA(1) ) {
            case RULE_INT:
                {
                alt12=1;
                }
                break;
            case RULE_SINGLE_QUOTED_STRING:
                {
                alt12=2;
                }
                break;
            case 79:
            case 80:
                {
                alt12=3;
                }
                break;
            case 18:
                {
                alt12=4;
                }
                break;
            case 63:
                {
                alt12=5;
                }
                break;
            case 64:
                {
                alt12=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }

            switch (alt12) {
                case 1 :
                    // InternalEOCL.g:2481:2: ( ruleNumberLiteralExpCS )
                    {
                    // InternalEOCL.g:2481:2: ( ruleNumberLiteralExpCS )
                    // InternalEOCL.g:2482:3: ruleNumberLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleNumberLiteralExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2487:2: ( ruleStringLiteralExpCS )
                    {
                    // InternalEOCL.g:2487:2: ( ruleStringLiteralExpCS )
                    // InternalEOCL.g:2488:3: ruleStringLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleStringLiteralExpCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2493:2: ( ruleBooleanLiteralExpCS )
                    {
                    // InternalEOCL.g:2493:2: ( ruleBooleanLiteralExpCS )
                    // InternalEOCL.g:2494:3: ruleBooleanLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleBooleanLiteralExpCS();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2499:2: ( ruleUnlimitedNaturalLiteralExpCS )
                    {
                    // InternalEOCL.g:2499:2: ( ruleUnlimitedNaturalLiteralExpCS )
                    // InternalEOCL.g:2500:3: ruleUnlimitedNaturalLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleUnlimitedNaturalLiteralExpCS();

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

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2505:2: ( ruleInvalidLiteralExpCS )
                    {
                    // InternalEOCL.g:2505:2: ( ruleInvalidLiteralExpCS )
                    // InternalEOCL.g:2506:3: ruleInvalidLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleInvalidLiteralExpCS();

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

                    }


                    }
                    break;
                case 6 :
                    // InternalEOCL.g:2511:2: ( ruleNullLiteralExpCS )
                    {
                    // InternalEOCL.g:2511:2: ( ruleNullLiteralExpCS )
                    // InternalEOCL.g:2512:3: ruleNullLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2521:1: rule__BooleanLiteralExpCS__Alternatives : ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) );
    public final void rule__BooleanLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2525:1: ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) )
            int alt13=2;
            int LA13_0 = input.LA(1);

            if ( (LA13_0==79) ) {
                alt13=1;
            }
            else if ( (LA13_0==80) ) {
                alt13=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }
            switch (alt13) {
                case 1 :
                    // InternalEOCL.g:2526:2: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    {
                    // InternalEOCL.g:2526:2: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    // InternalEOCL.g:2527:3: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0()); 
                    }
                    // InternalEOCL.g:2528:3: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    // InternalEOCL.g:2528:4: rule__BooleanLiteralExpCS__SymbolAssignment_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BooleanLiteralExpCS__SymbolAssignment_0();

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

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2532:2: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    {
                    // InternalEOCL.g:2532:2: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    // InternalEOCL.g:2533:3: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1()); 
                    }
                    // InternalEOCL.g:2534:3: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    // InternalEOCL.g:2534:4: rule__BooleanLiteralExpCS__SymbolAssignment_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:2542:1: rule__TypeLiteralCS__Alternatives : ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) );
    public final void rule__TypeLiteralCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2546:1: ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) )
            int alt14=4;
            switch ( input.LA(1) ) {
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
                {
                alt14=1;
                }
                break;
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
                {
                alt14=2;
                }
                break;
            case 35:
                {
                alt14=3;
                }
                break;
            case 36:
                {
                alt14=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }

            switch (alt14) {
                case 1 :
                    // InternalEOCL.g:2547:2: ( rulePrimitiveTypeCS )
                    {
                    // InternalEOCL.g:2547:2: ( rulePrimitiveTypeCS )
                    // InternalEOCL.g:2548:3: rulePrimitiveTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    rulePrimitiveTypeCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2553:2: ( ruleCollectionTypeCS )
                    {
                    // InternalEOCL.g:2553:2: ( ruleCollectionTypeCS )
                    // InternalEOCL.g:2554:3: ruleCollectionTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectionTypeCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2559:2: ( ruleMapTypeCS )
                    {
                    // InternalEOCL.g:2559:2: ( ruleMapTypeCS )
                    // InternalEOCL.g:2560:3: ruleMapTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleMapTypeCS();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2565:2: ( ruleTupleTypeCS )
                    {
                    // InternalEOCL.g:2565:2: ( ruleTupleTypeCS )
                    // InternalEOCL.g:2566:3: ruleTupleTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3()); 
                    }
                    pushFollow(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__TypeExpCS__Alternatives_0"
    // InternalEOCL.g:2575:1: rule__TypeExpCS__Alternatives_0 : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );
    public final void rule__TypeExpCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2579:1: ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) )
            int alt15=3;
            alt15 = dfa15.predict(input);
            switch (alt15) {
                case 1 :
                    // InternalEOCL.g:2580:2: ( ruleTypeNameExpCS )
                    {
                    // InternalEOCL.g:2580:2: ( ruleTypeNameExpCS )
                    // InternalEOCL.g:2581:3: ruleTypeNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpCSAccess().getTypeNameExpCSParserRuleCall_0_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleTypeNameExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2586:2: ( ruleTypeLiteralCS )
                    {
                    // InternalEOCL.g:2586:2: ( ruleTypeLiteralCS )
                    // InternalEOCL.g:2587:3: ruleTypeLiteralCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpCSAccess().getTypeLiteralCSParserRuleCall_0_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleTypeLiteralCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2592:2: ( ruleCollectionPatternCS )
                    {
                    // InternalEOCL.g:2592:2: ( ruleCollectionPatternCS )
                    // InternalEOCL.g:2593:3: ruleCollectionPatternCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpCSAccess().getCollectionPatternCSParserRuleCall_0_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectionPatternCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ExpCS__Alternatives"
    // InternalEOCL.g:2602:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );
    public final void rule__ExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2606:1: ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) )
            int alt16=2;
            alt16 = dfa16.predict(input);
            switch (alt16) {
                case 1 :
                    // InternalEOCL.g:2607:2: ( ( rule__ExpCS__Group_0__0 ) )
                    {
                    // InternalEOCL.g:2607:2: ( ( rule__ExpCS__Group_0__0 ) )
                    // InternalEOCL.g:2608:3: ( rule__ExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getGroup_0()); 
                    }
                    // InternalEOCL.g:2609:3: ( rule__ExpCS__Group_0__0 )
                    // InternalEOCL.g:2609:4: rule__ExpCS__Group_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2613:2: ( rulePrefixedLetExpCS )
                    {
                    // InternalEOCL.g:2613:2: ( rulePrefixedLetExpCS )
                    // InternalEOCL.g:2614:3: rulePrefixedLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2623:1: rule__PrefixedLetExpCS__Alternatives : ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) );
    public final void rule__PrefixedLetExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2627:1: ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) )
            int alt17=2;
            int LA17_0 = input.LA(1);

            if ( ((LA17_0>=16 && LA17_0<=17)) ) {
                alt17=1;
            }
            else if ( (LA17_0==74) ) {
                alt17=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }
            switch (alt17) {
                case 1 :
                    // InternalEOCL.g:2628:2: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    {
                    // InternalEOCL.g:2628:2: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    // InternalEOCL.g:2629:3: ( rule__PrefixedLetExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0()); 
                    }
                    // InternalEOCL.g:2630:3: ( rule__PrefixedLetExpCS__Group_0__0 )
                    // InternalEOCL.g:2630:4: rule__PrefixedLetExpCS__Group_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2634:2: ( ruleLetExpCS )
                    {
                    // InternalEOCL.g:2634:2: ( ruleLetExpCS )
                    // InternalEOCL.g:2635:3: ruleLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2644:1: rule__PrefixedPrimaryExpCS__Alternatives : ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) );
    public final void rule__PrefixedPrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2648:1: ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( ((LA18_0>=16 && LA18_0<=17)) ) {
                alt18=1;
            }
            else if ( ((LA18_0>=RULE_INT && LA18_0<=RULE_ESCAPED_ID)||LA18_0==18||(LA18_0>=35 && LA18_0<=49)||LA18_0==53||LA18_0==61||(LA18_0>=63 && LA18_0<=64)||LA18_0==69||LA18_0==75||(LA18_0>=79 && LA18_0<=80)) ) {
                alt18=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // InternalEOCL.g:2649:2: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    {
                    // InternalEOCL.g:2649:2: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    // InternalEOCL.g:2650:3: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0()); 
                    }
                    // InternalEOCL.g:2651:3: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    // InternalEOCL.g:2651:4: rule__PrefixedPrimaryExpCS__Group_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2655:2: ( rulePrimaryExpCS )
                    {
                    // InternalEOCL.g:2655:2: ( rulePrimaryExpCS )
                    // InternalEOCL.g:2656:3: rulePrimaryExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2665: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 {
            // InternalEOCL.g:2669:1: ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) )
            int alt19=10;
            alt19 = dfa19.predict(input);
            switch (alt19) {
                case 1 :
                    // InternalEOCL.g:2670:2: ( ruleNestedExpCS )
                    {
                    // InternalEOCL.g:2670:2: ( ruleNestedExpCS )
                    // InternalEOCL.g:2671:3: ruleNestedExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleNestedExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2676:2: ( ruleIfExpCS )
                    {
                    // InternalEOCL.g:2676:2: ( ruleIfExpCS )
                    // InternalEOCL.g:2677:3: ruleIfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleIfExpCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2682:2: ( ruleSelfExpCS )
                    {
                    // InternalEOCL.g:2682:2: ( ruleSelfExpCS )
                    // InternalEOCL.g:2683:3: ruleSelfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSelfExpCS();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalEOCL.g:2688:2: ( rulePrimitiveLiteralExpCS )
                    {
                    // InternalEOCL.g:2688:2: ( rulePrimitiveLiteralExpCS )
                    // InternalEOCL.g:2689:3: rulePrimitiveLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    rulePrimitiveLiteralExpCS();

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

                    }


                    }
                    break;
                case 5 :
                    // InternalEOCL.g:2694:2: ( ruleTupleLiteralExpCS )
                    {
                    // InternalEOCL.g:2694:2: ( ruleTupleLiteralExpCS )
                    // InternalEOCL.g:2695:3: ruleTupleLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleTupleLiteralExpCS();

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

                    }


                    }
                    break;
                case 6 :
                    // InternalEOCL.g:2700:2: ( ruleMapLiteralExpCS )
                    {
                    // InternalEOCL.g:2700:2: ( ruleMapLiteralExpCS )
                    // InternalEOCL.g:2701:3: ruleMapLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleMapLiteralExpCS();

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

                    }


                    }
                    break;
                case 7 :
                    // InternalEOCL.g:2706:2: ( ruleCollectionLiteralExpCS )
                    {
                    // InternalEOCL.g:2706:2: ( ruleCollectionLiteralExpCS )
                    // InternalEOCL.g:2707:3: ruleCollectionLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectionLiteralExpCS();

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

                    }


                    }
                    break;
                case 8 :
                    // InternalEOCL.g:2712:2: ( ruleLambdaLiteralExpCS )
                    {
                    // InternalEOCL.g:2712:2: ( ruleLambdaLiteralExpCS )
                    // InternalEOCL.g:2713:3: ruleLambdaLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleLambdaLiteralExpCS();

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

                    }


                    }
                    break;
                case 9 :
                    // InternalEOCL.g:2718:2: ( ruleTypeLiteralExpCS )
                    {
                    // InternalEOCL.g:2718:2: ( ruleTypeLiteralExpCS )
                    // InternalEOCL.g:2719:3: ruleTypeLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleTypeLiteralExpCS();

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

                    }


                    }
                    break;
                case 10 :
                    // InternalEOCL.g:2724:2: ( ruleNameExpCS )
                    {
                    // InternalEOCL.g:2724:2: ( ruleNameExpCS )
                    // InternalEOCL.g:2725:3: ruleNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9()); 
                    }
                    pushFollow(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__CurlyBracketedClauseCS__Alternatives_2"
    // InternalEOCL.g:2734:1: rule__CurlyBracketedClauseCS__Alternatives_2 : ( ( ( rule__CurlyBracketedClauseCS__Group_2_0__0 )? ) | ( ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 ) ) );
    public final void rule__CurlyBracketedClauseCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2738:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2_0__0 )? ) | ( ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 ) ) )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( ((LA21_0>=RULE_SIMPLE_ID && LA21_0<=RULE_ESCAPED_ID)||LA21_0==58) ) {
                alt21=1;
            }
            else if ( (LA21_0==RULE_SINGLE_QUOTED_STRING) ) {
                alt21=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;
            }
            switch (alt21) {
                case 1 :
                    // InternalEOCL.g:2739:2: ( ( rule__CurlyBracketedClauseCS__Group_2_0__0 )? )
                    {
                    // InternalEOCL.g:2739:2: ( ( rule__CurlyBracketedClauseCS__Group_2_0__0 )? )
                    // InternalEOCL.g:2740:3: ( rule__CurlyBracketedClauseCS__Group_2_0__0 )?
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_0()); 
                    }
                    // InternalEOCL.g:2741:3: ( rule__CurlyBracketedClauseCS__Group_2_0__0 )?
                    int alt20=2;
                    int LA20_0 = input.LA(1);

                    if ( ((LA20_0>=RULE_SIMPLE_ID && LA20_0<=RULE_ESCAPED_ID)) ) {
                        alt20=1;
                    }
                    switch (alt20) {
                        case 1 :
                            // InternalEOCL.g:2741:4: rule__CurlyBracketedClauseCS__Group_2_0__0
                            {
                            pushFollow(FOLLOW_2);
                            rule__CurlyBracketedClauseCS__Group_2_0__0();

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

                            }
                            break;

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2745:2: ( ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 ) )
                    {
                    // InternalEOCL.g:2745:2: ( ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 ) )
                    // InternalEOCL.g:2746:3: ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCurlyBracketedClauseCSAccess().getValueAssignment_2_1()); 
                    }
                    // InternalEOCL.g:2747:3: ( rule__CurlyBracketedClauseCS__ValueAssignment_2_1 )
                    // InternalEOCL.g:2747:4: rule__CurlyBracketedClauseCS__ValueAssignment_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__CurlyBracketedClauseCS__ValueAssignment_2_1();

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

                    }

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingArgCS__Alternatives"
    // InternalEOCL.g:2755: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 {
            // InternalEOCL.g:2759:1: ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( ((LA22_0>=RULE_INT && LA22_0<=RULE_ESCAPED_ID)||(LA22_0>=16 && LA22_0<=18)||(LA22_0>=35 && LA22_0<=49)||LA22_0==53||LA22_0==61||(LA22_0>=63 && LA22_0<=64)||LA22_0==69||(LA22_0>=74 && LA22_0<=75)||(LA22_0>=79 && LA22_0<=80)) ) {
                alt22=1;
            }
            else if ( (LA22_0==56) ) {
                alt22=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // InternalEOCL.g:2760:2: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    {
                    // InternalEOCL.g:2760:2: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    // InternalEOCL.g:2761:3: ( rule__NavigatingArgCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0()); 
                    }
                    // InternalEOCL.g:2762:3: ( rule__NavigatingArgCS__Group_0__0 )
                    // InternalEOCL.g:2762:4: rule__NavigatingArgCS__Group_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2766:2: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    {
                    // InternalEOCL.g:2766:2: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    // InternalEOCL.g:2767:3: ( rule__NavigatingArgCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_1()); 
                    }
                    // InternalEOCL.g:2768:3: ( rule__NavigatingArgCS__Group_1__0 )
                    // InternalEOCL.g:2768:4: rule__NavigatingArgCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:2776:1: rule__NavigatingArgCS__Alternatives_0_1 : ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2780:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) )
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==56) ) {
                alt23=1;
            }
            else if ( (LA23_0==68) ) {
                alt23=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }
            switch (alt23) {
                case 1 :
                    // InternalEOCL.g:2781:2: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    {
                    // InternalEOCL.g:2781:2: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    // InternalEOCL.g:2782:3: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0()); 
                    }
                    // InternalEOCL.g:2783:3: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    // InternalEOCL.g:2783:4: rule__NavigatingArgCS__Group_0_1_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2787:2: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    {
                    // InternalEOCL.g:2787:2: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    // InternalEOCL.g:2788:3: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1()); 
                    }
                    // InternalEOCL.g:2789:3: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    // InternalEOCL.g:2789:4: rule__NavigatingArgCS__Group_0_1_1__0
                    {
                    pushFollow(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;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2"
    // InternalEOCL.g:2797:1: rule__NavigatingCommaArgCS__Alternatives_2 : ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2801:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) )
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==56) ) {
                alt24=1;
            }
            else if ( (LA24_0==68) ) {
                alt24=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }
            switch (alt24) {
                case 1 :
                    // InternalEOCL.g:2802:2: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    {
                    // InternalEOCL.g:2802:2: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    // InternalEOCL.g:2803:3: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0()); 
                    }
                    // InternalEOCL.g:2804:3: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    // InternalEOCL.g:2804:4: rule__NavigatingCommaArgCS__Group_2_0__0
                    {
                    pushFollow(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 :
                    // InternalEOCL.g:2808:2: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    {
                    // InternalEOCL.g:2808:2: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    // InternalEOCL.g:2809:3: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1()); 
                    }
                    // InternalEOCL.g:2810:3: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    // InternalEOCL.g:2810:4: rule__NavigatingCommaArgCS__Group_2_1__0
                    {
                    pushFollow(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;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IfExpCS__OwnedConditionAlternatives_1_0"
    // InternalEOCL.g:2818:1: rule__IfExpCS__OwnedConditionAlternatives_1_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__IfExpCS__OwnedConditionAlternatives_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2822:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt25=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 16:
            case 17:
            case 18:
            case 35:
            case 36:
            case 37:
            case 38:
            case 39:
            case 40:
            case 41:
            case 42:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 53:
            case 61:
            case 63:
            case 64:
            case 69:
            case 74:
            case 75:
            case 79:
            case 80:
                {
                alt25=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA25_2 = input.LA(2);

                if ( (LA25_2==56) ) {
                    alt25=2;
                }
                else if ( (LA25_2==16||(LA25_2>=18 && LA25_2<=34)||LA25_2==53||LA25_2==57||LA25_2==66||LA25_2==70||LA25_2==76||LA25_2==81) ) {
                    alt25=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 25, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA25_3 = input.LA(2);

                if ( (LA25_3==16||(LA25_3>=18 && LA25_3<=34)||LA25_3==53||LA25_3==57||LA25_3==66||LA25_3==70||LA25_3==76||LA25_3==81) ) {
                    alt25=1;
                }
                else if ( (LA25_3==56) ) {
                    alt25=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 25, 3, input);

                    throw nvae;
                }
                }
                break;
            case 56:
                {
                alt25=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }

            switch (alt25) {
                case 1 :
                    // InternalEOCL.g:2823:2: ( ruleExpCS )
                    {
                    // InternalEOCL.g:2823:2: ( ruleExpCS )
                    // InternalEOCL.g:2824:3: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2829:2: ( rulePatternExpCS )
                    {
                    // InternalEOCL.g:2829:2: ( rulePatternExpCS )
                    // InternalEOCL.g:2830:3: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2839:1: rule__MultiplicityCS__Alternatives_1 : ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) );
    public final void rule__MultiplicityCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2843:1: ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) )
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==RULE_INT) ) {
                alt26=1;
            }
            else if ( (LA26_0==18||LA26_0==20||LA26_0==51) ) {
                alt26=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }
            switch (alt26) {
                case 1 :
                    // InternalEOCL.g:2844:2: ( ruleMultiplicityBoundsCS )
                    {
                    // InternalEOCL.g:2844:2: ( ruleMultiplicityBoundsCS )
                    // InternalEOCL.g:2845:3: ruleMultiplicityBoundsCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleMultiplicityBoundsCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2850:2: ( ruleMultiplicityStringCS )
                    {
                    // InternalEOCL.g:2850:2: ( ruleMultiplicityStringCS )
                    // InternalEOCL.g:2851:3: ruleMultiplicityStringCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2860:1: rule__MultiplicityCS__Alternatives_2 : ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) );
    public final void rule__MultiplicityCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2864:1: ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) )
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==50) ) {
                alt27=1;
            }
            else if ( (LA27_0==84) ) {
                alt27=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }
            switch (alt27) {
                case 1 :
                    // InternalEOCL.g:2865:2: ( '|?' )
                    {
                    // InternalEOCL.g:2865:2: ( '|?' )
                    // InternalEOCL.g:2866:3: '|?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0()); 
                    }
                    match(input,50,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2871:2: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    {
                    // InternalEOCL.g:2871:2: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    // InternalEOCL.g:2872:3: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1()); 
                    }
                    // InternalEOCL.g:2873:3: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    // InternalEOCL.g:2873:4: rule__MultiplicityCS__IsNullFreeAssignment_2_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:2881:1: rule__MultiplicityStringCS__StringBoundsAlternatives_0 : ( ( '*' ) | ( '+' ) | ( '?' ) );
    public final void rule__MultiplicityStringCS__StringBoundsAlternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2885:1: ( ( '*' ) | ( '+' ) | ( '?' ) )
            int alt28=3;
            switch ( input.LA(1) ) {
            case 18:
                {
                alt28=1;
                }
                break;
            case 20:
                {
                alt28=2;
                }
                break;
            case 51:
                {
                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 :
                    // InternalEOCL.g:2886:2: ( '*' )
                    {
                    // InternalEOCL.g:2886:2: ( '*' )
                    // InternalEOCL.g:2887:3: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0()); 
                    }
                    match(input,18,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2892:2: ( '+' )
                    {
                    // InternalEOCL.g:2892:2: ( '+' )
                    // InternalEOCL.g:2893:3: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1()); 
                    }
                    match(input,20,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1()); 
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalEOCL.g:2898:2: ( '?' )
                    {
                    // InternalEOCL.g:2898:2: ( '?' )
                    // InternalEOCL.g:2899:3: '?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2()); 
                    }
                    match(input,51,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"
    // InternalEOCL.g:2908:1: rule__TypeRefCS__Alternatives : ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) );
    public final void rule__TypeRefCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2912:1: ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) )
            int alt29=2;
            int LA29_0 = input.LA(1);

            if ( ((LA29_0>=RULE_SIMPLE_ID && LA29_0<=RULE_ESCAPED_ID)) ) {
                alt29=1;
            }
            else if ( (LA29_0==51) ) {
                alt29=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }
            switch (alt29) {
                case 1 :
                    // InternalEOCL.g:2913:2: ( ruleTypedRefCS )
                    {
                    // InternalEOCL.g:2913:2: ( ruleTypedRefCS )
                    // InternalEOCL.g:2914:3: ruleTypedRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleTypedRefCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2919:2: ( ruleWildcardTypeRefCS )
                    {
                    // InternalEOCL.g:2919:2: ( ruleWildcardTypeRefCS )
                    // InternalEOCL.g:2920:3: ruleWildcardTypeRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1()); 
                    }
                    pushFollow(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"
    // InternalEOCL.g:2929:1: rule__ID__Alternatives : ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) );
    public final void rule__ID__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2933:1: ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==RULE_SIMPLE_ID) ) {
                alt30=1;
            }
            else if ( (LA30_0==RULE_ESCAPED_ID) ) {
                alt30=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // InternalEOCL.g:2934:2: ( RULE_SIMPLE_ID )
                    {
                    // InternalEOCL.g:2934:2: ( RULE_SIMPLE_ID )
                    // InternalEOCL.g:2935:3: RULE_SIMPLE_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0()); 
                    }
                    match(input,RULE_SIMPLE_ID,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2940:2: ( RULE_ESCAPED_ID )
                    {
                    // InternalEOCL.g:2940:2: ( RULE_ESCAPED_ID )
                    // InternalEOCL.g:2941:3: RULE_ESCAPED_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1()); 
                    }
                    match(input,RULE_ESCAPED_ID,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"
    // InternalEOCL.g:2950:1: rule__UPPER__Alternatives : ( ( RULE_INT ) | ( '*' ) );
    public final void rule__UPPER__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2954:1: ( ( RULE_INT ) | ( '*' ) )
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==RULE_INT) ) {
                alt31=1;
            }
            else if ( (LA31_0==18) ) {
                alt31=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }
            switch (alt31) {
                case 1 :
                    // InternalEOCL.g:2955:2: ( RULE_INT )
                    {
                    // InternalEOCL.g:2955:2: ( RULE_INT )
                    // InternalEOCL.g:2956:3: RULE_INT
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0()); 
                    }
                    match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalEOCL.g:2961:2: ( '*' )
                    {
                    // InternalEOCL.g:2961:2: ( '*' )
                    // InternalEOCL.g:2962:3: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getAsteriskKeyword_1()); 
                    }
                    match(input,18,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__Greeting__Group__0"
    // InternalEOCL.g:2971:1: rule__Greeting__Group__0 : rule__Greeting__Group__0__Impl rule__Greeting__Group__1 ;
    public final void rule__Greeting__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2975:1: ( rule__Greeting__Group__0__Impl rule__Greeting__Group__1 )
            // InternalEOCL.g:2976:2: rule__Greeting__Group__0__Impl rule__Greeting__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__Greeting__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__Greeting__Group__1();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Greeting__Group__0__Impl"
    // InternalEOCL.g:2983:1: rule__Greeting__Group__0__Impl : ( 'Hello' ) ;
    public final void rule__Greeting__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:2987:1: ( ( 'Hello' ) )
            // InternalEOCL.g:2988:1: ( 'Hello' )
            {
            // InternalEOCL.g:2988:1: ( 'Hello' )
            // InternalEOCL.g:2989:2: 'Hello'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGreetingAccess().getHelloKeyword_0()); 
            }
            match(input,52,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getGreetingAccess().getHelloKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Greeting__Group__1"
    // InternalEOCL.g:2998:1: rule__Greeting__Group__1 : rule__Greeting__Group__1__Impl ;
    public final void rule__Greeting__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3002:1: ( rule__Greeting__Group__1__Impl )
            // InternalEOCL.g:3003:2: rule__Greeting__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__Greeting__Group__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Greeting__Group__1__Impl"
    // InternalEOCL.g:3009:1: rule__Greeting__Group__1__Impl : ( ( rule__Greeting__ModelAssignment_1 ) ) ;
    public final void rule__Greeting__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3013:1: ( ( ( rule__Greeting__ModelAssignment_1 ) ) )
            // InternalEOCL.g:3014:1: ( ( rule__Greeting__ModelAssignment_1 ) )
            {
            // InternalEOCL.g:3014:1: ( ( rule__Greeting__ModelAssignment_1 ) )
            // InternalEOCL.g:3015:2: ( rule__Greeting__ModelAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGreetingAccess().getModelAssignment_1()); 
            }
            // InternalEOCL.g:3016:2: ( rule__Greeting__ModelAssignment_1 )
            // InternalEOCL.g:3016:3: rule__Greeting__ModelAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__Greeting__ModelAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getGreetingAccess().getModelAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0"
    // InternalEOCL.g:3025: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 {
            // InternalEOCL.g:3029:1: ( rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 )
            // InternalEOCL.g:3030:2: rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1
            {
            pushFollow(FOLLOW_5);
            rule__URIFirstPathElementCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3037:1: rule__URIFirstPathElementCS__Group_1__0__Impl : ( () ) ;
    public final void rule__URIFirstPathElementCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3041:1: ( ( () ) )
            // InternalEOCL.g:3042:1: ( () )
            {
            // InternalEOCL.g:3042:1: ( () )
            // InternalEOCL.g:3043:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0()); 
            }
            // InternalEOCL.g:3044:2: ()
            // InternalEOCL.g:3044:3: 
            {
            }

            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"
    // InternalEOCL.g:3052: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 {
            // InternalEOCL.g:3056:1: ( rule__URIFirstPathElementCS__Group_1__1__Impl )
            // InternalEOCL.g:3057:2: rule__URIFirstPathElementCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3063: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 {
            // InternalEOCL.g:3067:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) )
            // InternalEOCL.g:3068:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            {
            // InternalEOCL.g:3068:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            // InternalEOCL.g:3069:2: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1()); 
            }
            // InternalEOCL.g:3070:2: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            // InternalEOCL.g:3070:3: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:3079: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 {
            // InternalEOCL.g:3083:1: ( rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 )
            // InternalEOCL.g:3084:2: rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__CollectionTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3091:1: rule__CollectionTypeCS__Group__0__Impl : ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) ;
    public final void rule__CollectionTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3095:1: ( ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:3096:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:3096:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            // InternalEOCL.g:3097:2: ( rule__CollectionTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:3098:2: ( rule__CollectionTypeCS__NameAssignment_0 )
            // InternalEOCL.g:3098:3: rule__CollectionTypeCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:3106:1: rule__CollectionTypeCS__Group__1 : rule__CollectionTypeCS__Group__1__Impl ;
    public final void rule__CollectionTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3110:1: ( rule__CollectionTypeCS__Group__1__Impl )
            // InternalEOCL.g:3111:2: rule__CollectionTypeCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3117: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 {
            // InternalEOCL.g:3121:1: ( ( ( rule__CollectionTypeCS__Group_1__0 )? ) )
            // InternalEOCL.g:3122:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            {
            // InternalEOCL.g:3122:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            // InternalEOCL.g:3123:2: ( rule__CollectionTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:3124:2: ( rule__CollectionTypeCS__Group_1__0 )?
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( (LA32_0==53) ) {
                alt32=1;
            }
            switch (alt32) {
                case 1 :
                    // InternalEOCL.g:3124:3: rule__CollectionTypeCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3133: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 {
            // InternalEOCL.g:3137:1: ( rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 )
            // InternalEOCL.g:3138:2: rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__CollectionTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3145:1: rule__CollectionTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__CollectionTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3149:1: ( ( '(' ) )
            // InternalEOCL.g:3150:1: ( '(' )
            {
            // InternalEOCL.g:3150:1: ( '(' )
            // InternalEOCL.g:3151:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0()); 
            }
            match(input,53,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"
    // InternalEOCL.g:3160: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 {
            // InternalEOCL.g:3164:1: ( rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 )
            // InternalEOCL.g:3165:2: rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2
            {
            pushFollow(FOLLOW_8);
            rule__CollectionTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3172: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 {
            // InternalEOCL.g:3176:1: ( ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEOCL.g:3177:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEOCL.g:3177:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            // InternalEOCL.g:3178:2: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1()); 
            }
            // InternalEOCL.g:3179:2: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            // InternalEOCL.g:3179:3: rule__CollectionTypeCS__OwnedTypeAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:3187:1: rule__CollectionTypeCS__Group_1__2 : rule__CollectionTypeCS__Group_1__2__Impl ;
    public final void rule__CollectionTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3191:1: ( rule__CollectionTypeCS__Group_1__2__Impl )
            // InternalEOCL.g:3192:2: rule__CollectionTypeCS__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CollectionTypeCS__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__CollectionTypeCS__Group_1__2"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__2__Impl"
    // InternalEOCL.g:3198:1: rule__CollectionTypeCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__CollectionTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3202:1: ( ( ')' ) )
            // InternalEOCL.g:3203:1: ( ')' )
            {
            // InternalEOCL.g:3203:1: ( ')' )
            // InternalEOCL.g:3204:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_2()); 
            }
            match(input,54,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_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__MapTypeCS__Group__0"
    // InternalEOCL.g:3214: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 {
            // InternalEOCL.g:3218:1: ( rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 )
            // InternalEOCL.g:3219:2: rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__MapTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3226:1: rule__MapTypeCS__Group__0__Impl : ( ( rule__MapTypeCS__NameAssignment_0 ) ) ;
    public final void rule__MapTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3230:1: ( ( ( rule__MapTypeCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:3231:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:3231:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            // InternalEOCL.g:3232:2: ( rule__MapTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:3233:2: ( rule__MapTypeCS__NameAssignment_0 )
            // InternalEOCL.g:3233:3: rule__MapTypeCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:3241:1: rule__MapTypeCS__Group__1 : rule__MapTypeCS__Group__1__Impl ;
    public final void rule__MapTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3245:1: ( rule__MapTypeCS__Group__1__Impl )
            // InternalEOCL.g:3246:2: rule__MapTypeCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3252: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 {
            // InternalEOCL.g:3256:1: ( ( ( rule__MapTypeCS__Group_1__0 )? ) )
            // InternalEOCL.g:3257:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            {
            // InternalEOCL.g:3257:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            // InternalEOCL.g:3258:2: ( rule__MapTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:3259:2: ( rule__MapTypeCS__Group_1__0 )?
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==53) ) {
                alt33=1;
            }
            switch (alt33) {
                case 1 :
                    // InternalEOCL.g:3259:3: rule__MapTypeCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3268: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 {
            // InternalEOCL.g:3272:1: ( rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 )
            // InternalEOCL.g:3273:2: rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__MapTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3280:1: rule__MapTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__MapTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3284:1: ( ( '(' ) )
            // InternalEOCL.g:3285:1: ( '(' )
            {
            // InternalEOCL.g:3285:1: ( '(' )
            // InternalEOCL.g:3286:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0()); 
            }
            match(input,53,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"
    // InternalEOCL.g:3295: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 {
            // InternalEOCL.g:3299:1: ( rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 )
            // InternalEOCL.g:3300:2: rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2
            {
            pushFollow(FOLLOW_9);
            rule__MapTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3307: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 {
            // InternalEOCL.g:3311:1: ( ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) )
            // InternalEOCL.g:3312:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            {
            // InternalEOCL.g:3312:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            // InternalEOCL.g:3313:2: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1()); 
            }
            // InternalEOCL.g:3314:2: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            // InternalEOCL.g:3314:3: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:3322: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 {
            // InternalEOCL.g:3326:1: ( rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 )
            // InternalEOCL.g:3327:2: rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3
            {
            pushFollow(FOLLOW_7);
            rule__MapTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3334:1: rule__MapTypeCS__Group_1__2__Impl : ( ',' ) ;
    public final void rule__MapTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3338:1: ( ( ',' ) )
            // InternalEOCL.g:3339:1: ( ',' )
            {
            // InternalEOCL.g:3339:1: ( ',' )
            // InternalEOCL.g:3340:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2()); 
            }
            match(input,55,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"
    // InternalEOCL.g:3349: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 {
            // InternalEOCL.g:3353:1: ( rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 )
            // InternalEOCL.g:3354:2: rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4
            {
            pushFollow(FOLLOW_8);
            rule__MapTypeCS__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3361: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 {
            // InternalEOCL.g:3365:1: ( ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) )
            // InternalEOCL.g:3366:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            {
            // InternalEOCL.g:3366:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            // InternalEOCL.g:3367:2: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3()); 
            }
            // InternalEOCL.g:3368:2: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            // InternalEOCL.g:3368:3: rule__MapTypeCS__OwnedValueTypeAssignment_1_3
            {
            pushFollow(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"
    // InternalEOCL.g:3376: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 {
            // InternalEOCL.g:3380:1: ( rule__MapTypeCS__Group_1__4__Impl )
            // InternalEOCL.g:3381:2: rule__MapTypeCS__Group_1__4__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3387:1: rule__MapTypeCS__Group_1__4__Impl : ( ')' ) ;
    public final void rule__MapTypeCS__Group_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3391:1: ( ( ')' ) )
            // InternalEOCL.g:3392:1: ( ')' )
            {
            // InternalEOCL.g:3392:1: ( ')' )
            // InternalEOCL.g:3393:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4()); 
            }
            match(input,54,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"
    // InternalEOCL.g:3403: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 {
            // InternalEOCL.g:3407:1: ( rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 )
            // InternalEOCL.g:3408:2: rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__TupleTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3415:1: rule__TupleTypeCS__Group__0__Impl : ( ( rule__TupleTypeCS__NameAssignment_0 ) ) ;
    public final void rule__TupleTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3419:1: ( ( ( rule__TupleTypeCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:3420:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:3420:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            // InternalEOCL.g:3421:2: ( rule__TupleTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:3422:2: ( rule__TupleTypeCS__NameAssignment_0 )
            // InternalEOCL.g:3422:3: rule__TupleTypeCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:3430:1: rule__TupleTypeCS__Group__1 : rule__TupleTypeCS__Group__1__Impl ;
    public final void rule__TupleTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3434:1: ( rule__TupleTypeCS__Group__1__Impl )
            // InternalEOCL.g:3435:2: rule__TupleTypeCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3441: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 {
            // InternalEOCL.g:3445:1: ( ( ( rule__TupleTypeCS__Group_1__0 )? ) )
            // InternalEOCL.g:3446:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            {
            // InternalEOCL.g:3446:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            // InternalEOCL.g:3447:2: ( rule__TupleTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:3448:2: ( rule__TupleTypeCS__Group_1__0 )?
            int alt34=2;
            int LA34_0 = input.LA(1);

            if ( (LA34_0==53) ) {
                alt34=1;
            }
            switch (alt34) {
                case 1 :
                    // InternalEOCL.g:3448:3: rule__TupleTypeCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3457: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 {
            // InternalEOCL.g:3461:1: ( rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 )
            // InternalEOCL.g:3462:2: rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1
            {
            pushFollow(FOLLOW_10);
            rule__TupleTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3469:1: rule__TupleTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TupleTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3473:1: ( ( '(' ) )
            // InternalEOCL.g:3474:1: ( '(' )
            {
            // InternalEOCL.g:3474:1: ( '(' )
            // InternalEOCL.g:3475:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0()); 
            }
            match(input,53,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"
    // InternalEOCL.g:3484: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 {
            // InternalEOCL.g:3488:1: ( rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 )
            // InternalEOCL.g:3489:2: rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2
            {
            pushFollow(FOLLOW_10);
            rule__TupleTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3496: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 {
            // InternalEOCL.g:3500:1: ( ( ( rule__TupleTypeCS__Group_1_1__0 )? ) )
            // InternalEOCL.g:3501:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            {
            // InternalEOCL.g:3501:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            // InternalEOCL.g:3502:2: ( rule__TupleTypeCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1()); 
            }
            // InternalEOCL.g:3503:2: ( rule__TupleTypeCS__Group_1_1__0 )?
            int alt35=2;
            int LA35_0 = input.LA(1);

            if ( ((LA35_0>=RULE_SIMPLE_ID && LA35_0<=RULE_ESCAPED_ID)) ) {
                alt35=1;
            }
            switch (alt35) {
                case 1 :
                    // InternalEOCL.g:3503:3: rule__TupleTypeCS__Group_1_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3511: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 {
            // InternalEOCL.g:3515:1: ( rule__TupleTypeCS__Group_1__2__Impl )
            // InternalEOCL.g:3516:2: rule__TupleTypeCS__Group_1__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3522:1: rule__TupleTypeCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TupleTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3526:1: ( ( ')' ) )
            // InternalEOCL.g:3527:1: ( ')' )
            {
            // InternalEOCL.g:3527:1: ( ')' )
            // InternalEOCL.g:3528:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2()); 
            }
            match(input,54,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"
    // InternalEOCL.g:3538: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 {
            // InternalEOCL.g:3542:1: ( rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 )
            // InternalEOCL.g:3543:2: rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1
            {
            pushFollow(FOLLOW_9);
            rule__TupleTypeCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3550: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 {
            // InternalEOCL.g:3554:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) )
            // InternalEOCL.g:3555:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            {
            // InternalEOCL.g:3555:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            // InternalEOCL.g:3556:2: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0()); 
            }
            // InternalEOCL.g:3557:2: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            // InternalEOCL.g:3557:3: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0
            {
            pushFollow(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"
    // InternalEOCL.g:3565: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 {
            // InternalEOCL.g:3569:1: ( rule__TupleTypeCS__Group_1_1__1__Impl )
            // InternalEOCL.g:3570:2: rule__TupleTypeCS__Group_1_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3576: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 {
            // InternalEOCL.g:3580:1: ( ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) )
            // InternalEOCL.g:3581:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            {
            // InternalEOCL.g:3581:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            // InternalEOCL.g:3582:2: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1()); 
            }
            // InternalEOCL.g:3583:2: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            loop36:
            do {
                int alt36=2;
                int LA36_0 = input.LA(1);

                if ( (LA36_0==55) ) {
                    alt36=1;
                }


                switch (alt36) {
            	case 1 :
            	    // InternalEOCL.g:3583:3: rule__TupleTypeCS__Group_1_1_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__TupleTypeCS__Group_1_1_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop36;
                }
            } 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"
    // InternalEOCL.g:3592: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 {
            // InternalEOCL.g:3596:1: ( rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 )
            // InternalEOCL.g:3597:2: rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1
            {
            pushFollow(FOLLOW_7);
            rule__TupleTypeCS__Group_1_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3604: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 {
            // InternalEOCL.g:3608:1: ( ( ',' ) )
            // InternalEOCL.g:3609:1: ( ',' )
            {
            // InternalEOCL.g:3609:1: ( ',' )
            // InternalEOCL.g:3610:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:3619: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 {
            // InternalEOCL.g:3623:1: ( rule__TupleTypeCS__Group_1_1_1__1__Impl )
            // InternalEOCL.g:3624:2: rule__TupleTypeCS__Group_1_1_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3630: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 {
            // InternalEOCL.g:3634:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) )
            // InternalEOCL.g:3635:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            {
            // InternalEOCL.g:3635:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            // InternalEOCL.g:3636:2: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1()); 
            }
            // InternalEOCL.g:3637:2: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            // InternalEOCL.g:3637:3: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:3646: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 {
            // InternalEOCL.g:3650:1: ( rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 )
            // InternalEOCL.g:3651:2: rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1
            {
            pushFollow(FOLLOW_12);
            rule__TuplePartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3658:1: rule__TuplePartCS__Group__0__Impl : ( ( rule__TuplePartCS__NameAssignment_0 ) ) ;
    public final void rule__TuplePartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3662:1: ( ( ( rule__TuplePartCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:3663:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:3663:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            // InternalEOCL.g:3664:2: ( rule__TuplePartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:3665:2: ( rule__TuplePartCS__NameAssignment_0 )
            // InternalEOCL.g:3665:3: rule__TuplePartCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:3673: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 {
            // InternalEOCL.g:3677:1: ( rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 )
            // InternalEOCL.g:3678:2: rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__TuplePartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3685:1: rule__TuplePartCS__Group__1__Impl : ( ':' ) ;
    public final void rule__TuplePartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3689:1: ( ( ':' ) )
            // InternalEOCL.g:3690:1: ( ':' )
            {
            // InternalEOCL.g:3690:1: ( ':' )
            // InternalEOCL.g:3691:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getColonKeyword_1()); 
            }
            match(input,56,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"
    // InternalEOCL.g:3700:1: rule__TuplePartCS__Group__2 : rule__TuplePartCS__Group__2__Impl ;
    public final void rule__TuplePartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3704:1: ( rule__TuplePartCS__Group__2__Impl )
            // InternalEOCL.g:3705:2: rule__TuplePartCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3711:1: rule__TuplePartCS__Group__2__Impl : ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) ;
    public final void rule__TuplePartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3715:1: ( ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) )
            // InternalEOCL.g:3716:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            {
            // InternalEOCL.g:3716:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            // InternalEOCL.g:3717:2: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2()); 
            }
            // InternalEOCL.g:3718:2: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            // InternalEOCL.g:3718:3: rule__TuplePartCS__OwnedTypeAssignment_2
            {
            pushFollow(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"
    // InternalEOCL.g:3727: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 {
            // InternalEOCL.g:3731:1: ( rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 )
            // InternalEOCL.g:3732:2: rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__CollectionLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3739:1: rule__CollectionLiteralExpCS__Group__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3743:1: ( ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalEOCL.g:3744:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEOCL.g:3744:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalEOCL.g:3745:2: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0()); 
            }
            // InternalEOCL.g:3746:2: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalEOCL.g:3746:3: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:3754: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 {
            // InternalEOCL.g:3758:1: ( rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 )
            // InternalEOCL.g:3759:2: rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2
            {
            pushFollow(FOLLOW_14);
            rule__CollectionLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3766:1: rule__CollectionLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3770:1: ( ( '{' ) )
            // InternalEOCL.g:3771:1: ( '{' )
            {
            // InternalEOCL.g:3771:1: ( '{' )
            // InternalEOCL.g:3772:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:3781: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 {
            // InternalEOCL.g:3785:1: ( rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 )
            // InternalEOCL.g:3786:2: rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3
            {
            pushFollow(FOLLOW_14);
            rule__CollectionLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3793: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 {
            // InternalEOCL.g:3797:1: ( ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) )
            // InternalEOCL.g:3798:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            {
            // InternalEOCL.g:3798:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            // InternalEOCL.g:3799:2: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:3800:2: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            int alt37=2;
            int LA37_0 = input.LA(1);

            if ( ((LA37_0>=RULE_INT && LA37_0<=RULE_ESCAPED_ID)||(LA37_0>=16 && LA37_0<=18)||(LA37_0>=35 && LA37_0<=49)||LA37_0==53||LA37_0==56||LA37_0==61||(LA37_0>=63 && LA37_0<=64)||LA37_0==69||(LA37_0>=74 && LA37_0<=75)||(LA37_0>=79 && LA37_0<=80)) ) {
                alt37=1;
            }
            switch (alt37) {
                case 1 :
                    // InternalEOCL.g:3800:3: rule__CollectionLiteralExpCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3808:1: rule__CollectionLiteralExpCS__Group__3 : rule__CollectionLiteralExpCS__Group__3__Impl ;
    public final void rule__CollectionLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3812:1: ( rule__CollectionLiteralExpCS__Group__3__Impl )
            // InternalEOCL.g:3813:2: rule__CollectionLiteralExpCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3819:1: rule__CollectionLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3823:1: ( ( '}' ) )
            // InternalEOCL.g:3824:1: ( '}' )
            {
            // InternalEOCL.g:3824:1: ( '}' )
            // InternalEOCL.g:3825:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,58,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"
    // InternalEOCL.g:3835: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 {
            // InternalEOCL.g:3839:1: ( rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 )
            // InternalEOCL.g:3840:2: rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1
            {
            pushFollow(FOLLOW_9);
            rule__CollectionLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3847: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 {
            // InternalEOCL.g:3851:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEOCL.g:3852:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEOCL.g:3852:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalEOCL.g:3853:2: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); 
            }
            // InternalEOCL.g:3854:2: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalEOCL.g:3854:3: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(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"
    // InternalEOCL.g:3862: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 {
            // InternalEOCL.g:3866:1: ( rule__CollectionLiteralExpCS__Group_2__1__Impl )
            // InternalEOCL.g:3867:2: rule__CollectionLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3873: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 {
            // InternalEOCL.g:3877:1: ( ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) )
            // InternalEOCL.g:3878:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalEOCL.g:3878:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            // InternalEOCL.g:3879:2: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1()); 
            }
            // InternalEOCL.g:3880:2: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            loop38:
            do {
                int alt38=2;
                int LA38_0 = input.LA(1);

                if ( (LA38_0==55) ) {
                    alt38=1;
                }


                switch (alt38) {
            	case 1 :
            	    // InternalEOCL.g:3880:3: rule__CollectionLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__CollectionLiteralExpCS__Group_2_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop38;
                }
            } 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"
    // InternalEOCL.g:3889: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 {
            // InternalEOCL.g:3893:1: ( rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 )
            // InternalEOCL.g:3894:2: rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1
            {
            pushFollow(FOLLOW_15);
            rule__CollectionLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3901:1: rule__CollectionLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:3905:1: ( ( ',' ) )
            // InternalEOCL.g:3906:1: ( ',' )
            {
            // InternalEOCL.g:3906:1: ( ',' )
            // InternalEOCL.g:3907:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:3916: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 {
            // InternalEOCL.g:3920:1: ( rule__CollectionLiteralExpCS__Group_2_1__1__Impl )
            // InternalEOCL.g:3921:2: rule__CollectionLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3927: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 {
            // InternalEOCL.g:3931:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEOCL.g:3932:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEOCL.g:3932:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEOCL.g:3933:2: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); 
            }
            // InternalEOCL.g:3934:2: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalEOCL.g:3934:3: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:3943: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 {
            // InternalEOCL.g:3947:1: ( rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 )
            // InternalEOCL.g:3948:2: rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1
            {
            pushFollow(FOLLOW_16);
            rule__CollectionLiteralPartCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:3955: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 {
            // InternalEOCL.g:3959:1: ( ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) )
            // InternalEOCL.g:3960:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            {
            // InternalEOCL.g:3960:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            // InternalEOCL.g:3961:2: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0()); 
            }
            // InternalEOCL.g:3962:2: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            // InternalEOCL.g:3962:3: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0
            {
            pushFollow(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"
    // InternalEOCL.g:3970: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 {
            // InternalEOCL.g:3974:1: ( rule__CollectionLiteralPartCS__Group_0__1__Impl )
            // InternalEOCL.g:3975:2: rule__CollectionLiteralPartCS__Group_0__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:3981: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 {
            // InternalEOCL.g:3985:1: ( ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) )
            // InternalEOCL.g:3986:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            {
            // InternalEOCL.g:3986:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            // InternalEOCL.g:3987:2: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1()); 
            }
            // InternalEOCL.g:3988:2: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( (LA39_0==59) ) {
                alt39=1;
            }
            switch (alt39) {
                case 1 :
                    // InternalEOCL.g:3988:3: rule__CollectionLiteralPartCS__Group_0_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:3997: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 {
            // InternalEOCL.g:4001:1: ( rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 )
            // InternalEOCL.g:4002:2: rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1
            {
            pushFollow(FOLLOW_4);
            rule__CollectionLiteralPartCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4009:1: rule__CollectionLiteralPartCS__Group_0_1__0__Impl : ( '..' ) ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4013:1: ( ( '..' ) )
            // InternalEOCL.g:4014:1: ( '..' )
            {
            // InternalEOCL.g:4014:1: ( '..' )
            // InternalEOCL.g:4015:2: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0()); 
            }
            match(input,59,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"
    // InternalEOCL.g:4024: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 {
            // InternalEOCL.g:4028:1: ( rule__CollectionLiteralPartCS__Group_0_1__1__Impl )
            // InternalEOCL.g:4029:2: rule__CollectionLiteralPartCS__Group_0_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4035: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 {
            // InternalEOCL.g:4039:1: ( ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) )
            // InternalEOCL.g:4040:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            {
            // InternalEOCL.g:4040:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            // InternalEOCL.g:4041:2: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1()); 
            }
            // InternalEOCL.g:4042:2: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            // InternalEOCL.g:4042:3: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:4051: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 {
            // InternalEOCL.g:4055:1: ( rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 )
            // InternalEOCL.g:4056:2: rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__CollectionPatternCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4063:1: rule__CollectionPatternCS__Group__0__Impl : ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionPatternCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4067:1: ( ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) )
            // InternalEOCL.g:4068:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEOCL.g:4068:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            // InternalEOCL.g:4069:2: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0()); 
            }
            // InternalEOCL.g:4070:2: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            // InternalEOCL.g:4070:3: rule__CollectionPatternCS__OwnedTypeAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:4078: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 {
            // InternalEOCL.g:4082:1: ( rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 )
            // InternalEOCL.g:4083:2: rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2
            {
            pushFollow(FOLLOW_14);
            rule__CollectionPatternCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4090:1: rule__CollectionPatternCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionPatternCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4094:1: ( ( '{' ) )
            // InternalEOCL.g:4095:1: ( '{' )
            {
            // InternalEOCL.g:4095:1: ( '{' )
            // InternalEOCL.g:4096:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:4105: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 {
            // InternalEOCL.g:4109:1: ( rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 )
            // InternalEOCL.g:4110:2: rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3
            {
            pushFollow(FOLLOW_14);
            rule__CollectionPatternCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4117: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 {
            // InternalEOCL.g:4121:1: ( ( ( rule__CollectionPatternCS__Group_2__0 )? ) )
            // InternalEOCL.g:4122:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            {
            // InternalEOCL.g:4122:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            // InternalEOCL.g:4123:2: ( rule__CollectionPatternCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:4124:2: ( rule__CollectionPatternCS__Group_2__0 )?
            int alt40=2;
            int LA40_0 = input.LA(1);

            if ( ((LA40_0>=RULE_SIMPLE_ID && LA40_0<=RULE_ESCAPED_ID)||LA40_0==56) ) {
                alt40=1;
            }
            switch (alt40) {
                case 1 :
                    // InternalEOCL.g:4124:3: rule__CollectionPatternCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:4132:1: rule__CollectionPatternCS__Group__3 : rule__CollectionPatternCS__Group__3__Impl ;
    public final void rule__CollectionPatternCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4136:1: ( rule__CollectionPatternCS__Group__3__Impl )
            // InternalEOCL.g:4137:2: rule__CollectionPatternCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4143:1: rule__CollectionPatternCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionPatternCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4147:1: ( ( '}' ) )
            // InternalEOCL.g:4148:1: ( '}' )
            {
            // InternalEOCL.g:4148:1: ( '}' )
            // InternalEOCL.g:4149:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,58,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"
    // InternalEOCL.g:4159: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 {
            // InternalEOCL.g:4163:1: ( rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 )
            // InternalEOCL.g:4164:2: rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1
            {
            pushFollow(FOLLOW_17);
            rule__CollectionPatternCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4171: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 {
            // InternalEOCL.g:4175:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEOCL.g:4176:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEOCL.g:4176:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            // InternalEOCL.g:4177:2: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0()); 
            }
            // InternalEOCL.g:4178:2: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            // InternalEOCL.g:4178:3: rule__CollectionPatternCS__OwnedPartsAssignment_2_0
            {
            pushFollow(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"
    // InternalEOCL.g:4186: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 {
            // InternalEOCL.g:4190:1: ( rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 )
            // InternalEOCL.g:4191:2: rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2
            {
            pushFollow(FOLLOW_17);
            rule__CollectionPatternCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4198: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 {
            // InternalEOCL.g:4202:1: ( ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) )
            // InternalEOCL.g:4203:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            {
            // InternalEOCL.g:4203:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            // InternalEOCL.g:4204:2: ( rule__CollectionPatternCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1()); 
            }
            // InternalEOCL.g:4205:2: ( rule__CollectionPatternCS__Group_2_1__0 )*
            loop41:
            do {
                int alt41=2;
                int LA41_0 = input.LA(1);

                if ( (LA41_0==55) ) {
                    alt41=1;
                }


                switch (alt41) {
            	case 1 :
            	    // InternalEOCL.g:4205:3: rule__CollectionPatternCS__Group_2_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__CollectionPatternCS__Group_2_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop41;
                }
            } 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"
    // InternalEOCL.g:4213: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 {
            // InternalEOCL.g:4217:1: ( rule__CollectionPatternCS__Group_2__2__Impl )
            // InternalEOCL.g:4218:2: rule__CollectionPatternCS__Group_2__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4224: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 {
            // InternalEOCL.g:4228:1: ( ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) )
            // InternalEOCL.g:4229:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            {
            // InternalEOCL.g:4229:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            // InternalEOCL.g:4230:2: ( rule__CollectionPatternCS__Group_2_2__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2()); 
            }
            // InternalEOCL.g:4231:2: ( rule__CollectionPatternCS__Group_2_2__0 )
            // InternalEOCL.g:4231:3: rule__CollectionPatternCS__Group_2_2__0
            {
            pushFollow(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"
    // InternalEOCL.g:4240: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 {
            // InternalEOCL.g:4244:1: ( rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 )
            // InternalEOCL.g:4245:2: rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1
            {
            pushFollow(FOLLOW_15);
            rule__CollectionPatternCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4252:1: rule__CollectionPatternCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionPatternCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4256:1: ( ( ',' ) )
            // InternalEOCL.g:4257:1: ( ',' )
            {
            // InternalEOCL.g:4257:1: ( ',' )
            // InternalEOCL.g:4258:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:4267: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 {
            // InternalEOCL.g:4271:1: ( rule__CollectionPatternCS__Group_2_1__1__Impl )
            // InternalEOCL.g:4272:2: rule__CollectionPatternCS__Group_2_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4278: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 {
            // InternalEOCL.g:4282:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEOCL.g:4283:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEOCL.g:4283:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEOCL.g:4284:2: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1()); 
            }
            // InternalEOCL.g:4285:2: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            // InternalEOCL.g:4285:3: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:4294: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 {
            // InternalEOCL.g:4298:1: ( rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 )
            // InternalEOCL.g:4299:2: rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1
            {
            pushFollow(FOLLOW_7);
            rule__CollectionPatternCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4306:1: rule__CollectionPatternCS__Group_2_2__0__Impl : ( '++' ) ;
    public final void rule__CollectionPatternCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4310:1: ( ( '++' ) )
            // InternalEOCL.g:4311:1: ( '++' )
            {
            // InternalEOCL.g:4311:1: ( '++' )
            // InternalEOCL.g:4312:2: '++'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0()); 
            }
            match(input,60,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"
    // InternalEOCL.g:4321: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 {
            // InternalEOCL.g:4325:1: ( rule__CollectionPatternCS__Group_2_2__1__Impl )
            // InternalEOCL.g:4326:2: rule__CollectionPatternCS__Group_2_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4332: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 {
            // InternalEOCL.g:4336:1: ( ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) )
            // InternalEOCL.g:4337:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            {
            // InternalEOCL.g:4337:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            // InternalEOCL.g:4338:2: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1()); 
            }
            // InternalEOCL.g:4339:2: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            // InternalEOCL.g:4339:3: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:4348:1: rule__ShadowPartCS__Group__0 : rule__ShadowPartCS__Group__0__Impl rule__ShadowPartCS__Group__1 ;
    public final void rule__ShadowPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4352:1: ( rule__ShadowPartCS__Group__0__Impl rule__ShadowPartCS__Group__1 )
            // InternalEOCL.g:4353:2: rule__ShadowPartCS__Group__0__Impl rule__ShadowPartCS__Group__1
            {
            pushFollow(FOLLOW_18);
            rule__ShadowPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__Group__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"


    // $ANTLR start "rule__ShadowPartCS__Group__0__Impl"
    // InternalEOCL.g:4360:1: rule__ShadowPartCS__Group__0__Impl : ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0 ) ) ;
    public final void rule__ShadowPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4364:1: ( ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0 ) ) )
            // InternalEOCL.g:4365:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0 ) )
            {
            // InternalEOCL.g:4365:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0 ) )
            // InternalEOCL.g:4366:2: ( rule__ShadowPartCS__ReferredPropertyAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0()); 
            }
            // InternalEOCL.g:4367:2: ( rule__ShadowPartCS__ReferredPropertyAssignment_0 )
            // InternalEOCL.g:4367:3: rule__ShadowPartCS__ReferredPropertyAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__ReferredPropertyAssignment_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ShadowPartCS__Group__1"
    // InternalEOCL.g:4375:1: rule__ShadowPartCS__Group__1 : rule__ShadowPartCS__Group__1__Impl rule__ShadowPartCS__Group__2 ;
    public final void rule__ShadowPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4379:1: ( rule__ShadowPartCS__Group__1__Impl rule__ShadowPartCS__Group__2 )
            // InternalEOCL.g:4380:2: rule__ShadowPartCS__Group__1__Impl rule__ShadowPartCS__Group__2
            {
            pushFollow(FOLLOW_15);
            rule__ShadowPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__Group__2();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ShadowPartCS__Group__1__Impl"
    // InternalEOCL.g:4387:1: rule__ShadowPartCS__Group__1__Impl : ( '=' ) ;
    public final void rule__ShadowPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4391:1: ( ( '=' ) )
            // InternalEOCL.g:4392:1: ( '=' )
            {
            // InternalEOCL.g:4392:1: ( '=' )
            // InternalEOCL.g:4393:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_1()); 
            }
            match(input,25,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ShadowPartCS__Group__2"
    // InternalEOCL.g:4402:1: rule__ShadowPartCS__Group__2 : rule__ShadowPartCS__Group__2__Impl ;
    public final void rule__ShadowPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4406:1: ( rule__ShadowPartCS__Group__2__Impl )
            // InternalEOCL.g:4407:2: rule__ShadowPartCS__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__Group__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__2"


    // $ANTLR start "rule__ShadowPartCS__Group__2__Impl"
    // InternalEOCL.g:4413:1: rule__ShadowPartCS__Group__2__Impl : ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 ) ) ;
    public final void rule__ShadowPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4417:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 ) ) )
            // InternalEOCL.g:4418:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 ) )
            {
            // InternalEOCL.g:4418:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 ) )
            // InternalEOCL.g:4419:2: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_2()); 
            }
            // InternalEOCL.g:4420:2: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_2 )
            // InternalEOCL.g:4420:3: rule__ShadowPartCS__OwnedInitExpressionAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAssignment_2();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PatternExpCS__Group__0"
    // InternalEOCL.g:4429: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 {
            // InternalEOCL.g:4433:1: ( rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 )
            // InternalEOCL.g:4434:2: rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1
            {
            pushFollow(FOLLOW_15);
            rule__PatternExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4441:1: rule__PatternExpCS__Group__0__Impl : ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) ;
    public final void rule__PatternExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4445:1: ( ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) )
            // InternalEOCL.g:4446:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            {
            // InternalEOCL.g:4446:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            // InternalEOCL.g:4447:2: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0()); 
            }
            // InternalEOCL.g:4448:2: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            int alt42=2;
            int LA42_0 = input.LA(1);

            if ( ((LA42_0>=RULE_SIMPLE_ID && LA42_0<=RULE_ESCAPED_ID)) ) {
                alt42=1;
            }
            switch (alt42) {
                case 1 :
                    // InternalEOCL.g:4448:3: rule__PatternExpCS__PatternVariableNameAssignment_0
                    {
                    pushFollow(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"
    // InternalEOCL.g:4456: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 {
            // InternalEOCL.g:4460:1: ( rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 )
            // InternalEOCL.g:4461:2: rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__PatternExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4468:1: rule__PatternExpCS__Group__1__Impl : ( ':' ) ;
    public final void rule__PatternExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4472:1: ( ( ':' ) )
            // InternalEOCL.g:4473:1: ( ':' )
            {
            // InternalEOCL.g:4473:1: ( ':' )
            // InternalEOCL.g:4474:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getColonKeyword_1()); 
            }
            match(input,56,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"
    // InternalEOCL.g:4483:1: rule__PatternExpCS__Group__2 : rule__PatternExpCS__Group__2__Impl ;
    public final void rule__PatternExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4487:1: ( rule__PatternExpCS__Group__2__Impl )
            // InternalEOCL.g:4488:2: rule__PatternExpCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4494:1: rule__PatternExpCS__Group__2__Impl : ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) ;
    public final void rule__PatternExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4498:1: ( ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) )
            // InternalEOCL.g:4499:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            {
            // InternalEOCL.g:4499:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            // InternalEOCL.g:4500:2: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2()); 
            }
            // InternalEOCL.g:4501:2: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            // InternalEOCL.g:4501:3: rule__PatternExpCS__OwnedPatternTypeAssignment_2
            {
            pushFollow(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"
    // InternalEOCL.g:4510: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 {
            // InternalEOCL.g:4514:1: ( rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 )
            // InternalEOCL.g:4515:2: rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__LambdaLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4522:1: rule__LambdaLiteralExpCS__Group__0__Impl : ( 'Lambda' ) ;
    public final void rule__LambdaLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4526:1: ( ( 'Lambda' ) )
            // InternalEOCL.g:4527:1: ( 'Lambda' )
            {
            // InternalEOCL.g:4527:1: ( 'Lambda' )
            // InternalEOCL.g:4528:2: 'Lambda'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0()); 
            }
            match(input,61,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"
    // InternalEOCL.g:4537: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 {
            // InternalEOCL.g:4541:1: ( rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 )
            // InternalEOCL.g:4542:2: rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2
            {
            pushFollow(FOLLOW_4);
            rule__LambdaLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4549:1: rule__LambdaLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__LambdaLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4553:1: ( ( '{' ) )
            // InternalEOCL.g:4554:1: ( '{' )
            {
            // InternalEOCL.g:4554:1: ( '{' )
            // InternalEOCL.g:4555:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:4564: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 {
            // InternalEOCL.g:4568:1: ( rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 )
            // InternalEOCL.g:4569:2: rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3
            {
            pushFollow(FOLLOW_19);
            rule__LambdaLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4576:1: rule__LambdaLiteralExpCS__Group__2__Impl : ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) ;
    public final void rule__LambdaLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4580:1: ( ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) )
            // InternalEOCL.g:4581:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            {
            // InternalEOCL.g:4581:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            // InternalEOCL.g:4582:2: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2()); 
            }
            // InternalEOCL.g:4583:2: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            // InternalEOCL.g:4583:3: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2
            {
            pushFollow(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"
    // InternalEOCL.g:4591:1: rule__LambdaLiteralExpCS__Group__3 : rule__LambdaLiteralExpCS__Group__3__Impl ;
    public final void rule__LambdaLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4595:1: ( rule__LambdaLiteralExpCS__Group__3__Impl )
            // InternalEOCL.g:4596:2: rule__LambdaLiteralExpCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4602:1: rule__LambdaLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__LambdaLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4606:1: ( ( '}' ) )
            // InternalEOCL.g:4607:1: ( '}' )
            {
            // InternalEOCL.g:4607:1: ( '}' )
            // InternalEOCL.g:4608:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,58,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"
    // InternalEOCL.g:4618: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 {
            // InternalEOCL.g:4622:1: ( rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 )
            // InternalEOCL.g:4623:2: rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__MapLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4630:1: rule__MapLiteralExpCS__Group__0__Impl : ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__MapLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4634:1: ( ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalEOCL.g:4635:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalEOCL.g:4635:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalEOCL.g:4636:2: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0()); 
            }
            // InternalEOCL.g:4637:2: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalEOCL.g:4637:3: rule__MapLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:4645: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 {
            // InternalEOCL.g:4649:1: ( rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 )
            // InternalEOCL.g:4650:2: rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2
            {
            pushFollow(FOLLOW_20);
            rule__MapLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4657:1: rule__MapLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__MapLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4661:1: ( ( '{' ) )
            // InternalEOCL.g:4662:1: ( '{' )
            {
            // InternalEOCL.g:4662:1: ( '{' )
            // InternalEOCL.g:4663:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:4672: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 {
            // InternalEOCL.g:4676:1: ( rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 )
            // InternalEOCL.g:4677:2: rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3
            {
            pushFollow(FOLLOW_20);
            rule__MapLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4684: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 {
            // InternalEOCL.g:4688:1: ( ( ( rule__MapLiteralExpCS__Group_2__0 )? ) )
            // InternalEOCL.g:4689:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            {
            // InternalEOCL.g:4689:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            // InternalEOCL.g:4690:2: ( rule__MapLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:4691:2: ( rule__MapLiteralExpCS__Group_2__0 )?
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( ((LA43_0>=RULE_INT && LA43_0<=RULE_ESCAPED_ID)||(LA43_0>=16 && LA43_0<=18)||(LA43_0>=35 && LA43_0<=49)||LA43_0==53||LA43_0==61||(LA43_0>=63 && LA43_0<=64)||LA43_0==69||(LA43_0>=74 && LA43_0<=75)||(LA43_0>=79 && LA43_0<=80)) ) {
                alt43=1;
            }
            switch (alt43) {
                case 1 :
                    // InternalEOCL.g:4691:3: rule__MapLiteralExpCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:4699:1: rule__MapLiteralExpCS__Group__3 : rule__MapLiteralExpCS__Group__3__Impl ;
    public final void rule__MapLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4703:1: ( rule__MapLiteralExpCS__Group__3__Impl )
            // InternalEOCL.g:4704:2: rule__MapLiteralExpCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4710:1: rule__MapLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__MapLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4714:1: ( ( '}' ) )
            // InternalEOCL.g:4715:1: ( '}' )
            {
            // InternalEOCL.g:4715:1: ( '}' )
            // InternalEOCL.g:4716:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,58,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"
    // InternalEOCL.g:4726: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 {
            // InternalEOCL.g:4730:1: ( rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 )
            // InternalEOCL.g:4731:2: rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1
            {
            pushFollow(FOLLOW_9);
            rule__MapLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4738: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 {
            // InternalEOCL.g:4742:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalEOCL.g:4743:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalEOCL.g:4743:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalEOCL.g:4744:2: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0()); 
            }
            // InternalEOCL.g:4745:2: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalEOCL.g:4745:3: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(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"
    // InternalEOCL.g:4753: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 {
            // InternalEOCL.g:4757:1: ( rule__MapLiteralExpCS__Group_2__1__Impl )
            // InternalEOCL.g:4758:2: rule__MapLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4764: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 {
            // InternalEOCL.g:4768:1: ( ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) )
            // InternalEOCL.g:4769:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalEOCL.g:4769:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            // InternalEOCL.g:4770:2: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1()); 
            }
            // InternalEOCL.g:4771:2: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            loop44:
            do {
                int alt44=2;
                int LA44_0 = input.LA(1);

                if ( (LA44_0==55) ) {
                    alt44=1;
                }


                switch (alt44) {
            	case 1 :
            	    // InternalEOCL.g:4771:3: rule__MapLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__MapLiteralExpCS__Group_2_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop44;
                }
            } 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"
    // InternalEOCL.g:4780: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 {
            // InternalEOCL.g:4784:1: ( rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 )
            // InternalEOCL.g:4785:2: rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1
            {
            pushFollow(FOLLOW_4);
            rule__MapLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4792:1: rule__MapLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__MapLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4796:1: ( ( ',' ) )
            // InternalEOCL.g:4797:1: ( ',' )
            {
            // InternalEOCL.g:4797:1: ( ',' )
            // InternalEOCL.g:4798:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:4807: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 {
            // InternalEOCL.g:4811:1: ( rule__MapLiteralExpCS__Group_2_1__1__Impl )
            // InternalEOCL.g:4812:2: rule__MapLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4818: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 {
            // InternalEOCL.g:4822:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalEOCL.g:4823:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalEOCL.g:4823:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalEOCL.g:4824:2: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1()); 
            }
            // InternalEOCL.g:4825:2: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalEOCL.g:4825:3: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:4834: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 {
            // InternalEOCL.g:4838:1: ( rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 )
            // InternalEOCL.g:4839:2: rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__MapLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4846:1: rule__MapLiteralPartCS__Group__0__Impl : ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) ;
    public final void rule__MapLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4850:1: ( ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) )
            // InternalEOCL.g:4851:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            {
            // InternalEOCL.g:4851:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            // InternalEOCL.g:4852:2: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0()); 
            }
            // InternalEOCL.g:4853:2: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            // InternalEOCL.g:4853:3: rule__MapLiteralPartCS__OwnedKeyAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:4861: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 {
            // InternalEOCL.g:4865:1: ( rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 )
            // InternalEOCL.g:4866:2: rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2
            {
            pushFollow(FOLLOW_4);
            rule__MapLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4873:1: rule__MapLiteralPartCS__Group__1__Impl : ( '<-' ) ;
    public final void rule__MapLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4877:1: ( ( '<-' ) )
            // InternalEOCL.g:4878:1: ( '<-' )
            {
            // InternalEOCL.g:4878:1: ( '<-' )
            // InternalEOCL.g:4879:2: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1()); 
            }
            match(input,62,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_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"
    // InternalEOCL.g:4888:1: rule__MapLiteralPartCS__Group__2 : rule__MapLiteralPartCS__Group__2__Impl ;
    public final void rule__MapLiteralPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4892:1: ( rule__MapLiteralPartCS__Group__2__Impl )
            // InternalEOCL.g:4893:2: rule__MapLiteralPartCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:4899:1: rule__MapLiteralPartCS__Group__2__Impl : ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) ;
    public final void rule__MapLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4903:1: ( ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) )
            // InternalEOCL.g:4904:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            {
            // InternalEOCL.g:4904:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            // InternalEOCL.g:4905:2: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2()); 
            }
            // InternalEOCL.g:4906:2: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            // InternalEOCL.g:4906:3: rule__MapLiteralPartCS__OwnedValueAssignment_2
            {
            pushFollow(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"
    // InternalEOCL.g:4915: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 {
            // InternalEOCL.g:4919:1: ( rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 )
            // InternalEOCL.g:4920:2: rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__TupleLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4927:1: rule__TupleLiteralExpCS__Group__0__Impl : ( 'Tuple' ) ;
    public final void rule__TupleLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4931:1: ( ( 'Tuple' ) )
            // InternalEOCL.g:4932:1: ( 'Tuple' )
            {
            // InternalEOCL.g:4932:1: ( 'Tuple' )
            // InternalEOCL.g:4933:2: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0()); 
            }
            match(input,36,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"
    // InternalEOCL.g:4942: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 {
            // InternalEOCL.g:4946:1: ( rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 )
            // InternalEOCL.g:4947:2: rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__TupleLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4954:1: rule__TupleLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__TupleLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4958:1: ( ( '{' ) )
            // InternalEOCL.g:4959:1: ( '{' )
            {
            // InternalEOCL.g:4959:1: ( '{' )
            // InternalEOCL.g:4960:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:4969: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 {
            // InternalEOCL.g:4973:1: ( rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 )
            // InternalEOCL.g:4974:2: rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3
            {
            pushFollow(FOLLOW_22);
            rule__TupleLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:4981:1: rule__TupleLiteralExpCS__Group__2__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) ;
    public final void rule__TupleLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:4985:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) )
            // InternalEOCL.g:4986:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            {
            // InternalEOCL.g:4986:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            // InternalEOCL.g:4987:2: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2()); 
            }
            // InternalEOCL.g:4988:2: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            // InternalEOCL.g:4988:3: rule__TupleLiteralExpCS__OwnedPartsAssignment_2
            {
            pushFollow(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"
    // InternalEOCL.g:4996: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 {
            // InternalEOCL.g:5000:1: ( rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 )
            // InternalEOCL.g:5001:2: rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4
            {
            pushFollow(FOLLOW_22);
            rule__TupleLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5008: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 {
            // InternalEOCL.g:5012:1: ( ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) )
            // InternalEOCL.g:5013:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            {
            // InternalEOCL.g:5013:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            // InternalEOCL.g:5014:2: ( rule__TupleLiteralExpCS__Group_3__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3()); 
            }
            // InternalEOCL.g:5015:2: ( rule__TupleLiteralExpCS__Group_3__0 )*
            loop45:
            do {
                int alt45=2;
                int LA45_0 = input.LA(1);

                if ( (LA45_0==55) ) {
                    alt45=1;
                }


                switch (alt45) {
            	case 1 :
            	    // InternalEOCL.g:5015:3: rule__TupleLiteralExpCS__Group_3__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__TupleLiteralExpCS__Group_3__0();

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

            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } 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"
    // InternalEOCL.g:5023:1: rule__TupleLiteralExpCS__Group__4 : rule__TupleLiteralExpCS__Group__4__Impl ;
    public final void rule__TupleLiteralExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5027:1: ( rule__TupleLiteralExpCS__Group__4__Impl )
            // InternalEOCL.g:5028:2: rule__TupleLiteralExpCS__Group__4__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5034:1: rule__TupleLiteralExpCS__Group__4__Impl : ( '}' ) ;
    public final void rule__TupleLiteralExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5038:1: ( ( '}' ) )
            // InternalEOCL.g:5039:1: ( '}' )
            {
            // InternalEOCL.g:5039:1: ( '}' )
            // InternalEOCL.g:5040:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4()); 
            }
            match(input,58,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"
    // InternalEOCL.g:5050: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 {
            // InternalEOCL.g:5054:1: ( rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 )
            // InternalEOCL.g:5055:2: rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1
            {
            pushFollow(FOLLOW_7);
            rule__TupleLiteralExpCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5062:1: rule__TupleLiteralExpCS__Group_3__0__Impl : ( ',' ) ;
    public final void rule__TupleLiteralExpCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5066:1: ( ( ',' ) )
            // InternalEOCL.g:5067:1: ( ',' )
            {
            // InternalEOCL.g:5067:1: ( ',' )
            // InternalEOCL.g:5068:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:5077: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 {
            // InternalEOCL.g:5081:1: ( rule__TupleLiteralExpCS__Group_3__1__Impl )
            // InternalEOCL.g:5082:2: rule__TupleLiteralExpCS__Group_3__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5088: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 {
            // InternalEOCL.g:5092:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) )
            // InternalEOCL.g:5093:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            {
            // InternalEOCL.g:5093:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            // InternalEOCL.g:5094:2: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1()); 
            }
            // InternalEOCL.g:5095:2: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            // InternalEOCL.g:5095:3: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1
            {
            pushFollow(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"
    // InternalEOCL.g:5104: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 {
            // InternalEOCL.g:5108:1: ( rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 )
            // InternalEOCL.g:5109:2: rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1
            {
            pushFollow(FOLLOW_23);
            rule__TupleLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5116:1: rule__TupleLiteralPartCS__Group__0__Impl : ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5120:1: ( ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:5121:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:5121:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            // InternalEOCL.g:5122:2: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:5123:2: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            // InternalEOCL.g:5123:3: rule__TupleLiteralPartCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:5131: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 {
            // InternalEOCL.g:5135:1: ( rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 )
            // InternalEOCL.g:5136:2: rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2
            {
            pushFollow(FOLLOW_23);
            rule__TupleLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5143: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 {
            // InternalEOCL.g:5147:1: ( ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) )
            // InternalEOCL.g:5148:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            {
            // InternalEOCL.g:5148:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            // InternalEOCL.g:5149:2: ( rule__TupleLiteralPartCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:5150:2: ( rule__TupleLiteralPartCS__Group_1__0 )?
            int alt46=2;
            int LA46_0 = input.LA(1);

            if ( (LA46_0==56) ) {
                alt46=1;
            }
            switch (alt46) {
                case 1 :
                    // InternalEOCL.g:5150:3: rule__TupleLiteralPartCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:5158: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 {
            // InternalEOCL.g:5162:1: ( rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 )
            // InternalEOCL.g:5163:2: rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3
            {
            pushFollow(FOLLOW_4);
            rule__TupleLiteralPartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5170:1: rule__TupleLiteralPartCS__Group__2__Impl : ( '=' ) ;
    public final void rule__TupleLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5174:1: ( ( '=' ) )
            // InternalEOCL.g:5175:1: ( '=' )
            {
            // InternalEOCL.g:5175:1: ( '=' )
            // InternalEOCL.g:5176:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2()); 
            }
            match(input,25,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"
    // InternalEOCL.g:5185:1: rule__TupleLiteralPartCS__Group__3 : rule__TupleLiteralPartCS__Group__3__Impl ;
    public final void rule__TupleLiteralPartCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5189:1: ( rule__TupleLiteralPartCS__Group__3__Impl )
            // InternalEOCL.g:5190:2: rule__TupleLiteralPartCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5196:1: rule__TupleLiteralPartCS__Group__3__Impl : ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5200:1: ( ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) )
            // InternalEOCL.g:5201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            {
            // InternalEOCL.g:5201:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            // InternalEOCL.g:5202:2: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3()); 
            }
            // InternalEOCL.g:5203:2: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            // InternalEOCL.g:5203:3: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3
            {
            pushFollow(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"
    // InternalEOCL.g:5212: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 {
            // InternalEOCL.g:5216:1: ( rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 )
            // InternalEOCL.g:5217:2: rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__TupleLiteralPartCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5224:1: rule__TupleLiteralPartCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__TupleLiteralPartCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5228:1: ( ( ':' ) )
            // InternalEOCL.g:5229:1: ( ':' )
            {
            // InternalEOCL.g:5229:1: ( ':' )
            // InternalEOCL.g:5230:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0()); 
            }
            match(input,56,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"
    // InternalEOCL.g:5239: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 {
            // InternalEOCL.g:5243:1: ( rule__TupleLiteralPartCS__Group_1__1__Impl )
            // InternalEOCL.g:5244:2: rule__TupleLiteralPartCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5250: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 {
            // InternalEOCL.g:5254:1: ( ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEOCL.g:5255:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEOCL.g:5255:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            // InternalEOCL.g:5256:2: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1()); 
            }
            // InternalEOCL.g:5257:2: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            // InternalEOCL.g:5257:3: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:5266: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 {
            // InternalEOCL.g:5270:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 )
            // InternalEOCL.g:5271:2: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_24);
            rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5278:1: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5282:1: ( ( () ) )
            // InternalEOCL.g:5283:1: ( () )
            {
            // InternalEOCL.g:5283:1: ( () )
            // InternalEOCL.g:5284:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0()); 
            }
            // InternalEOCL.g:5285:2: ()
            // InternalEOCL.g:5285:3: 
            {
            }

            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"
    // InternalEOCL.g:5293:1: rule__UnlimitedNaturalLiteralExpCS__Group__1 : rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5297:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl )
            // InternalEOCL.g:5298:2: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5304:1: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl : ( '*' ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5308:1: ( ( '*' ) )
            // InternalEOCL.g:5309:1: ( '*' )
            {
            // InternalEOCL.g:5309:1: ( '*' )
            // InternalEOCL.g:5310:2: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1()); 
            }
            match(input,18,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"
    // InternalEOCL.g:5320: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 {
            // InternalEOCL.g:5324:1: ( rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 )
            // InternalEOCL.g:5325:2: rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_25);
            rule__InvalidLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5332:1: rule__InvalidLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__InvalidLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5336:1: ( ( () ) )
            // InternalEOCL.g:5337:1: ( () )
            {
            // InternalEOCL.g:5337:1: ( () )
            // InternalEOCL.g:5338:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0()); 
            }
            // InternalEOCL.g:5339:2: ()
            // InternalEOCL.g:5339:3: 
            {
            }

            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"
    // InternalEOCL.g:5347:1: rule__InvalidLiteralExpCS__Group__1 : rule__InvalidLiteralExpCS__Group__1__Impl ;
    public final void rule__InvalidLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5351:1: ( rule__InvalidLiteralExpCS__Group__1__Impl )
            // InternalEOCL.g:5352:2: rule__InvalidLiteralExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5358:1: rule__InvalidLiteralExpCS__Group__1__Impl : ( 'invalid' ) ;
    public final void rule__InvalidLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5362:1: ( ( 'invalid' ) )
            // InternalEOCL.g:5363:1: ( 'invalid' )
            {
            // InternalEOCL.g:5363:1: ( 'invalid' )
            // InternalEOCL.g:5364:2: 'invalid'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1()); 
            }
            match(input,63,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"
    // InternalEOCL.g:5374: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 {
            // InternalEOCL.g:5378:1: ( rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 )
            // InternalEOCL.g:5379:2: rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_26);
            rule__NullLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5386:1: rule__NullLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__NullLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5390:1: ( ( () ) )
            // InternalEOCL.g:5391:1: ( () )
            {
            // InternalEOCL.g:5391:1: ( () )
            // InternalEOCL.g:5392:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0()); 
            }
            // InternalEOCL.g:5393:2: ()
            // InternalEOCL.g:5393:3: 
            {
            }

            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"
    // InternalEOCL.g:5401:1: rule__NullLiteralExpCS__Group__1 : rule__NullLiteralExpCS__Group__1__Impl ;
    public final void rule__NullLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5405:1: ( rule__NullLiteralExpCS__Group__1__Impl )
            // InternalEOCL.g:5406:2: rule__NullLiteralExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5412:1: rule__NullLiteralExpCS__Group__1__Impl : ( 'null' ) ;
    public final void rule__NullLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5416:1: ( ( 'null' ) )
            // InternalEOCL.g:5417:1: ( 'null' )
            {
            // InternalEOCL.g:5417:1: ( 'null' )
            // InternalEOCL.g:5418:2: 'null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1()); 
            }
            match(input,64,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"
    // InternalEOCL.g:5428: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 {
            // InternalEOCL.g:5432:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 )
            // InternalEOCL.g:5433:2: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1
            {
            pushFollow(FOLLOW_27);
            rule__TypeLiteralWithMultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5440:1: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl : ( ruleTypeLiteralCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5444:1: ( ( ruleTypeLiteralCS ) )
            // InternalEOCL.g:5445:1: ( ruleTypeLiteralCS )
            {
            // InternalEOCL.g:5445:1: ( ruleTypeLiteralCS )
            // InternalEOCL.g:5446:2: ruleTypeLiteralCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:5455:1: rule__TypeLiteralWithMultiplicityCS__Group__1 : rule__TypeLiteralWithMultiplicityCS__Group__1__Impl ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5459:1: ( rule__TypeLiteralWithMultiplicityCS__Group__1__Impl )
            // InternalEOCL.g:5460:2: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5466:1: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl : ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5470:1: ( ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalEOCL.g:5471:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalEOCL.g:5471:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            // InternalEOCL.g:5472:2: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1()); 
            }
            // InternalEOCL.g:5473:2: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( (LA47_0==66) ) {
                alt47=1;
            }
            switch (alt47) {
                case 1 :
                    // InternalEOCL.g:5473:3: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:5482: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 {
            // InternalEOCL.g:5486:1: ( rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 )
            // InternalEOCL.g:5487:2: rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__TypeNameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5494:1: rule__TypeNameExpCS__Group__0__Impl : ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypeNameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5498:1: ( ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEOCL.g:5499:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEOCL.g:5499:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalEOCL.g:5500:2: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0()); 
            }
            // InternalEOCL.g:5501:2: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            // InternalEOCL.g:5501:3: rule__TypeNameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:5509:1: rule__TypeNameExpCS__Group__1 : rule__TypeNameExpCS__Group__1__Impl ;
    public final void rule__TypeNameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5513:1: ( rule__TypeNameExpCS__Group__1__Impl )
            // InternalEOCL.g:5514:2: rule__TypeNameExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5520: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 {
            // InternalEOCL.g:5524:1: ( ( ( rule__TypeNameExpCS__Group_1__0 )? ) )
            // InternalEOCL.g:5525:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            {
            // InternalEOCL.g:5525:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            // InternalEOCL.g:5526:2: ( rule__TypeNameExpCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:5527:2: ( rule__TypeNameExpCS__Group_1__0 )?
            int alt48=2;
            int LA48_0 = input.LA(1);

            if ( (LA48_0==57) ) {
                alt48=1;
            }
            switch (alt48) {
                case 1 :
                    // InternalEOCL.g:5527:3: rule__TypeNameExpCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:5536: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 {
            // InternalEOCL.g:5540:1: ( rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 )
            // InternalEOCL.g:5541:2: rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1
            {
            pushFollow(FOLLOW_13);
            rule__TypeNameExpCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5548: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 {
            // InternalEOCL.g:5552:1: ( ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) )
            // InternalEOCL.g:5553:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            {
            // InternalEOCL.g:5553:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            // InternalEOCL.g:5554:2: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0()); 
            }
            // InternalEOCL.g:5555:2: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            // InternalEOCL.g:5555:3: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0
            {
            pushFollow(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"
    // InternalEOCL.g:5563: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 {
            // InternalEOCL.g:5567:1: ( rule__TypeNameExpCS__Group_1__1__Impl )
            // InternalEOCL.g:5568:2: rule__TypeNameExpCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5574: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 {
            // InternalEOCL.g:5578:1: ( ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) )
            // InternalEOCL.g:5579:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            {
            // InternalEOCL.g:5579:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            // InternalEOCL.g:5580:2: ( rule__TypeNameExpCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1()); 
            }
            // InternalEOCL.g:5581:2: ( rule__TypeNameExpCS__Group_1_1__0 )?
            int alt49=2;
            int LA49_0 = input.LA(1);

            if ( (LA49_0==57) ) {
                alt49=1;
            }
            switch (alt49) {
                case 1 :
                    // InternalEOCL.g:5581:3: rule__TypeNameExpCS__Group_1_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:5590: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 {
            // InternalEOCL.g:5594:1: ( rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 )
            // InternalEOCL.g:5595:2: rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1
            {
            pushFollow(FOLLOW_4);
            rule__TypeNameExpCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5602:1: rule__TypeNameExpCS__Group_1_1__0__Impl : ( '{' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5606:1: ( ( '{' ) )
            // InternalEOCL.g:5607:1: ( '{' )
            {
            // InternalEOCL.g:5607:1: ( '{' )
            // InternalEOCL.g:5608:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0()); 
            }
            match(input,57,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"
    // InternalEOCL.g:5617: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 {
            // InternalEOCL.g:5621:1: ( rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 )
            // InternalEOCL.g:5622:2: rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2
            {
            pushFollow(FOLLOW_19);
            rule__TypeNameExpCS__Group_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5629: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 {
            // InternalEOCL.g:5633:1: ( ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) )
            // InternalEOCL.g:5634:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            {
            // InternalEOCL.g:5634:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            // InternalEOCL.g:5635:2: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1()); 
            }
            // InternalEOCL.g:5636:2: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            // InternalEOCL.g:5636:3: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:5644: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 {
            // InternalEOCL.g:5648:1: ( rule__TypeNameExpCS__Group_1_1__2__Impl )
            // InternalEOCL.g:5649:2: rule__TypeNameExpCS__Group_1_1__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5655:1: rule__TypeNameExpCS__Group_1_1__2__Impl : ( '}' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5659:1: ( ( '}' ) )
            // InternalEOCL.g:5660:1: ( '}' )
            {
            // InternalEOCL.g:5660:1: ( '}' )
            // InternalEOCL.g:5661:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2()); 
            }
            match(input,58,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"
    // InternalEOCL.g:5671: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 {
            // InternalEOCL.g:5675:1: ( rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 )
            // InternalEOCL.g:5676:2: rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1
            {
            pushFollow(FOLLOW_27);
            rule__TypeExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5683:1: rule__TypeExpCS__Group__0__Impl : ( ( rule__TypeExpCS__Alternatives_0 ) ) ;
    public final void rule__TypeExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5687:1: ( ( ( rule__TypeExpCS__Alternatives_0 ) ) )
            // InternalEOCL.g:5688:1: ( ( rule__TypeExpCS__Alternatives_0 ) )
            {
            // InternalEOCL.g:5688:1: ( ( rule__TypeExpCS__Alternatives_0 ) )
            // InternalEOCL.g:5689:2: ( rule__TypeExpCS__Alternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getAlternatives_0()); 
            }
            // InternalEOCL.g:5690:2: ( rule__TypeExpCS__Alternatives_0 )
            // InternalEOCL.g:5690:3: rule__TypeExpCS__Alternatives_0
            {
            pushFollow(FOLLOW_2);
            rule__TypeExpCS__Alternatives_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getAlternatives_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"
    // InternalEOCL.g:5698:1: rule__TypeExpCS__Group__1 : rule__TypeExpCS__Group__1__Impl ;
    public final void rule__TypeExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5702:1: ( rule__TypeExpCS__Group__1__Impl )
            // InternalEOCL.g:5703:2: rule__TypeExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5709:1: rule__TypeExpCS__Group__1__Impl : ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5713:1: ( ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalEOCL.g:5714:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalEOCL.g:5714:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            // InternalEOCL.g:5715:2: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1()); 
            }
            // InternalEOCL.g:5716:2: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            int alt50=2;
            int LA50_0 = input.LA(1);

            if ( (LA50_0==66) ) {
                alt50=1;
            }
            switch (alt50) {
                case 1 :
                    // InternalEOCL.g:5716:3: rule__TypeExpCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:5725: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 {
            // InternalEOCL.g:5729:1: ( rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 )
            // InternalEOCL.g:5730:2: rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1
            {
            pushFollow(FOLLOW_28);
            rule__ExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5737:1: rule__ExpCS__Group_0__0__Impl : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__ExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5741:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalEOCL.g:5742:1: ( rulePrefixedPrimaryExpCS )
            {
            // InternalEOCL.g:5742:1: ( rulePrefixedPrimaryExpCS )
            // InternalEOCL.g:5743:2: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:5752: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 {
            // InternalEOCL.g:5756:1: ( rule__ExpCS__Group_0__1__Impl )
            // InternalEOCL.g:5757:2: rule__ExpCS__Group_0__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5763: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 {
            // InternalEOCL.g:5767:1: ( ( ( rule__ExpCS__Group_0_1__0 )? ) )
            // InternalEOCL.g:5768:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            {
            // InternalEOCL.g:5768:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            // InternalEOCL.g:5769:2: ( rule__ExpCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getGroup_0_1()); 
            }
            // InternalEOCL.g:5770:2: ( rule__ExpCS__Group_0_1__0 )?
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==16||(LA51_0>=18 && LA51_0<=34)) ) {
                alt51=1;
            }
            switch (alt51) {
                case 1 :
                    // InternalEOCL.g:5770:3: rule__ExpCS__Group_0_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:5779: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 {
            // InternalEOCL.g:5783:1: ( rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 )
            // InternalEOCL.g:5784:2: rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1
            {
            pushFollow(FOLLOW_28);
            rule__ExpCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5791:1: rule__ExpCS__Group_0_1__0__Impl : ( () ) ;
    public final void rule__ExpCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5795:1: ( ( () ) )
            // InternalEOCL.g:5796:1: ( () )
            {
            // InternalEOCL.g:5796:1: ( () )
            // InternalEOCL.g:5797:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0()); 
            }
            // InternalEOCL.g:5798:2: ()
            // InternalEOCL.g:5798:3: 
            {
            }

            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"
    // InternalEOCL.g:5806: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 {
            // InternalEOCL.g:5810:1: ( rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 )
            // InternalEOCL.g:5811:2: rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2
            {
            pushFollow(FOLLOW_4);
            rule__ExpCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5818: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 {
            // InternalEOCL.g:5822:1: ( ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) )
            // InternalEOCL.g:5823:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            {
            // InternalEOCL.g:5823:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            // InternalEOCL.g:5824:2: ( rule__ExpCS__NameAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1()); 
            }
            // InternalEOCL.g:5825:2: ( rule__ExpCS__NameAssignment_0_1_1 )
            // InternalEOCL.g:5825:3: rule__ExpCS__NameAssignment_0_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:5833: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 {
            // InternalEOCL.g:5837:1: ( rule__ExpCS__Group_0_1__2__Impl )
            // InternalEOCL.g:5838:2: rule__ExpCS__Group_0_1__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5844: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 {
            // InternalEOCL.g:5848:1: ( ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) )
            // InternalEOCL.g:5849:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            {
            // InternalEOCL.g:5849:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            // InternalEOCL.g:5850:2: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2()); 
            }
            // InternalEOCL.g:5851:2: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            // InternalEOCL.g:5851:3: rule__ExpCS__OwnedRightAssignment_0_1_2
            {
            pushFollow(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"
    // InternalEOCL.g:5860: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 {
            // InternalEOCL.g:5864:1: ( rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 )
            // InternalEOCL.g:5865:2: rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1
            {
            pushFollow(FOLLOW_29);
            rule__PrefixedLetExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5872:1: rule__PrefixedLetExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedLetExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5876:1: ( ( () ) )
            // InternalEOCL.g:5877:1: ( () )
            {
            // InternalEOCL.g:5877:1: ( () )
            // InternalEOCL.g:5878:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0()); 
            }
            // InternalEOCL.g:5879:2: ()
            // InternalEOCL.g:5879:3: 
            {
            }

            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"
    // InternalEOCL.g:5887: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 {
            // InternalEOCL.g:5891:1: ( rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 )
            // InternalEOCL.g:5892:2: rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2
            {
            pushFollow(FOLLOW_4);
            rule__PrefixedLetExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5899: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 {
            // InternalEOCL.g:5903:1: ( ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) )
            // InternalEOCL.g:5904:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            {
            // InternalEOCL.g:5904:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            // InternalEOCL.g:5905:2: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1()); 
            }
            // InternalEOCL.g:5906:2: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            // InternalEOCL.g:5906:3: rule__PrefixedLetExpCS__NameAssignment_0_1
            {
            pushFollow(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"
    // InternalEOCL.g:5914: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 {
            // InternalEOCL.g:5918:1: ( rule__PrefixedLetExpCS__Group_0__2__Impl )
            // InternalEOCL.g:5919:2: rule__PrefixedLetExpCS__Group_0__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:5925: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 {
            // InternalEOCL.g:5929:1: ( ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalEOCL.g:5930:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalEOCL.g:5930:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            // InternalEOCL.g:5931:2: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2()); 
            }
            // InternalEOCL.g:5932:2: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            // InternalEOCL.g:5932:3: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(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"
    // InternalEOCL.g:5941: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 {
            // InternalEOCL.g:5945:1: ( rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 )
            // InternalEOCL.g:5946:2: rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1
            {
            pushFollow(FOLLOW_29);
            rule__PrefixedPrimaryExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5953:1: rule__PrefixedPrimaryExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:5957:1: ( ( () ) )
            // InternalEOCL.g:5958:1: ( () )
            {
            // InternalEOCL.g:5958:1: ( () )
            // InternalEOCL.g:5959:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0()); 
            }
            // InternalEOCL.g:5960:2: ()
            // InternalEOCL.g:5960:3: 
            {
            }

            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"
    // InternalEOCL.g:5968: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 {
            // InternalEOCL.g:5972:1: ( rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 )
            // InternalEOCL.g:5973:2: rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2
            {
            pushFollow(FOLLOW_7);
            rule__PrefixedPrimaryExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:5980: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 {
            // InternalEOCL.g:5984:1: ( ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) )
            // InternalEOCL.g:5985:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            {
            // InternalEOCL.g:5985:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            // InternalEOCL.g:5986:2: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1()); 
            }
            // InternalEOCL.g:5987:2: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            // InternalEOCL.g:5987:3: rule__PrefixedPrimaryExpCS__NameAssignment_0_1
            {
            pushFollow(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"
    // InternalEOCL.g:5995: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 {
            // InternalEOCL.g:5999:1: ( rule__PrefixedPrimaryExpCS__Group_0__2__Impl )
            // InternalEOCL.g:6000:2: rule__PrefixedPrimaryExpCS__Group_0__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6006: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 {
            // InternalEOCL.g:6010:1: ( ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalEOCL.g:6011:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalEOCL.g:6011:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            // InternalEOCL.g:6012:2: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2()); 
            }
            // InternalEOCL.g:6013:2: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            // InternalEOCL.g:6013:3: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(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"
    // InternalEOCL.g:6022: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 {
            // InternalEOCL.g:6026:1: ( rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 )
            // InternalEOCL.g:6027:2: rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1
            {
            pushFollow(FOLLOW_30);
            rule__NameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6034:1: rule__NameExpCS__Group__0__Impl : ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__NameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6038:1: ( ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEOCL.g:6039:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEOCL.g:6039:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalEOCL.g:6040:2: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0()); 
            }
            // InternalEOCL.g:6041:2: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            // InternalEOCL.g:6041:3: rule__NameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:6049: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 {
            // InternalEOCL.g:6053:1: ( rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 )
            // InternalEOCL.g:6054:2: rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2
            {
            pushFollow(FOLLOW_30);
            rule__NameExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6061:1: rule__NameExpCS__Group__1__Impl : ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) ;
    public final void rule__NameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6065:1: ( ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) )
            // InternalEOCL.g:6066:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            {
            // InternalEOCL.g:6066:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            // InternalEOCL.g:6067:2: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1()); 
            }
            // InternalEOCL.g:6068:2: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            loop52:
            do {
                int alt52=2;
                int LA52_0 = input.LA(1);

                if ( (LA52_0==66) ) {
                    alt52=1;
                }


                switch (alt52) {
            	case 1 :
            	    // InternalEOCL.g:6068:3: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1
            	    {
            	    pushFollow(FOLLOW_31);
            	    rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1();

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

            	    }
            	    break;

            	default :
            	    break loop52;
                }
            } 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"
    // InternalEOCL.g:6076: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 {
            // InternalEOCL.g:6080:1: ( rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 )
            // InternalEOCL.g:6081:2: rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3
            {
            pushFollow(FOLLOW_30);
            rule__NameExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6088:1: rule__NameExpCS__Group__2__Impl : ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) ;
    public final void rule__NameExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6092:1: ( ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) )
            // InternalEOCL.g:6093:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            {
            // InternalEOCL.g:6093:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            // InternalEOCL.g:6094:2: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2()); 
            }
            // InternalEOCL.g:6095:2: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            int alt53=2;
            int LA53_0 = input.LA(1);

            if ( (LA53_0==53) ) {
                alt53=1;
            }
            switch (alt53) {
                case 1 :
                    // InternalEOCL.g:6095:3: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2
                    {
                    pushFollow(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"
    // InternalEOCL.g:6103: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 {
            // InternalEOCL.g:6107:1: ( rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 )
            // InternalEOCL.g:6108:2: rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4
            {
            pushFollow(FOLLOW_30);
            rule__NameExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6115:1: rule__NameExpCS__Group__3__Impl : ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) ;
    public final void rule__NameExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6119:1: ( ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) )
            // InternalEOCL.g:6120:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            {
            // InternalEOCL.g:6120:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            // InternalEOCL.g:6121:2: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3()); 
            }
            // InternalEOCL.g:6122:2: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( (LA54_0==57) ) {
                alt54=1;
            }
            switch (alt54) {
                case 1 :
                    // InternalEOCL.g:6122:3: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3
                    {
                    pushFollow(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"
    // InternalEOCL.g:6130:1: rule__NameExpCS__Group__4 : rule__NameExpCS__Group__4__Impl ;
    public final void rule__NameExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6134:1: ( rule__NameExpCS__Group__4__Impl )
            // InternalEOCL.g:6135:2: rule__NameExpCS__Group__4__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6141: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 {
            // InternalEOCL.g:6145:1: ( ( ( rule__NameExpCS__Group_4__0 )? ) )
            // InternalEOCL.g:6146:1: ( ( rule__NameExpCS__Group_4__0 )? )
            {
            // InternalEOCL.g:6146:1: ( ( rule__NameExpCS__Group_4__0 )? )
            // InternalEOCL.g:6147:2: ( rule__NameExpCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup_4()); 
            }
            // InternalEOCL.g:6148:2: ( rule__NameExpCS__Group_4__0 )?
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==81) ) {
                alt55=1;
            }
            switch (alt55) {
                case 1 :
                    // InternalEOCL.g:6148:3: rule__NameExpCS__Group_4__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:6157: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 {
            // InternalEOCL.g:6161:1: ( rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 )
            // InternalEOCL.g:6162:2: rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1
            {
            pushFollow(FOLLOW_32);
            rule__NameExpCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6169: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 {
            // InternalEOCL.g:6173:1: ( ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) )
            // InternalEOCL.g:6174:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            {
            // InternalEOCL.g:6174:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            // InternalEOCL.g:6175:2: ( rule__NameExpCS__IsPreAssignment_4_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0()); 
            }
            // InternalEOCL.g:6176:2: ( rule__NameExpCS__IsPreAssignment_4_0 )
            // InternalEOCL.g:6176:3: rule__NameExpCS__IsPreAssignment_4_0
            {
            pushFollow(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"
    // InternalEOCL.g:6184: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 {
            // InternalEOCL.g:6188:1: ( rule__NameExpCS__Group_4__1__Impl )
            // InternalEOCL.g:6189:2: rule__NameExpCS__Group_4__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6195:1: rule__NameExpCS__Group_4__1__Impl : ( 'pre' ) ;
    public final void rule__NameExpCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6199:1: ( ( 'pre' ) )
            // InternalEOCL.g:6200:1: ( 'pre' )
            {
            // InternalEOCL.g:6200:1: ( 'pre' )
            // InternalEOCL.g:6201:2: 'pre'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1()); 
            }
            match(input,65,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"
    // InternalEOCL.g:6211: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 {
            // InternalEOCL.g:6215:1: ( rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 )
            // InternalEOCL.g:6216:2: rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1
            {
            pushFollow(FOLLOW_13);
            rule__CurlyBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6223:1: rule__CurlyBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__CurlyBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6227:1: ( ( () ) )
            // InternalEOCL.g:6228:1: ( () )
            {
            // InternalEOCL.g:6228:1: ( () )
            // InternalEOCL.g:6229:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0()); 
            }
            // InternalEOCL.g:6230:2: ()
            // InternalEOCL.g:6230:3: 
            {
            }

            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"
    // InternalEOCL.g:6238: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 {
            // InternalEOCL.g:6242:1: ( rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 )
            // InternalEOCL.g:6243:2: rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__CurlyBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6250:1: rule__CurlyBracketedClauseCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6254:1: ( ( '{' ) )
            // InternalEOCL.g:6255:1: ( '{' )
            {
            // InternalEOCL.g:6255:1: ( '{' )
            // InternalEOCL.g:6256:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,57,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"
    // InternalEOCL.g:6265: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 {
            // InternalEOCL.g:6269:1: ( rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 )
            // InternalEOCL.g:6270:2: rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3
            {
            pushFollow(FOLLOW_19);
            rule__CurlyBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6277:1: rule__CurlyBracketedClauseCS__Group__2__Impl : ( ( rule__CurlyBracketedClauseCS__Alternatives_2 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6281:1: ( ( ( rule__CurlyBracketedClauseCS__Alternatives_2 ) ) )
            // InternalEOCL.g:6282:1: ( ( rule__CurlyBracketedClauseCS__Alternatives_2 ) )
            {
            // InternalEOCL.g:6282:1: ( ( rule__CurlyBracketedClauseCS__Alternatives_2 ) )
            // InternalEOCL.g:6283:2: ( rule__CurlyBracketedClauseCS__Alternatives_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getAlternatives_2()); 
            }
            // InternalEOCL.g:6284:2: ( rule__CurlyBracketedClauseCS__Alternatives_2 )
            // InternalEOCL.g:6284:3: rule__CurlyBracketedClauseCS__Alternatives_2
            {
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__Alternatives_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getAlternatives_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"
    // InternalEOCL.g:6292:1: rule__CurlyBracketedClauseCS__Group__3 : rule__CurlyBracketedClauseCS__Group__3__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6296:1: ( rule__CurlyBracketedClauseCS__Group__3__Impl )
            // InternalEOCL.g:6297:2: rule__CurlyBracketedClauseCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6303:1: rule__CurlyBracketedClauseCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6307:1: ( ( '}' ) )
            // InternalEOCL.g:6308:1: ( '}' )
            {
            // InternalEOCL.g:6308:1: ( '}' )
            // InternalEOCL.g:6309:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,58,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__0"
    // InternalEOCL.g:6319:1: rule__CurlyBracketedClauseCS__Group_2_0__0 : rule__CurlyBracketedClauseCS__Group_2_0__0__Impl rule__CurlyBracketedClauseCS__Group_2_0__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6323:1: ( rule__CurlyBracketedClauseCS__Group_2_0__0__Impl rule__CurlyBracketedClauseCS__Group_2_0__1 )
            // InternalEOCL.g:6324:2: rule__CurlyBracketedClauseCS__Group_2_0__0__Impl rule__CurlyBracketedClauseCS__Group_2_0__1
            {
            pushFollow(FOLLOW_9);
            rule__CurlyBracketedClauseCS__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__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__CurlyBracketedClauseCS__Group_2_0__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0__0__Impl"
    // InternalEOCL.g:6331:1: rule__CurlyBracketedClauseCS__Group_2_0__0__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6335:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 ) ) )
            // InternalEOCL.g:6336:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 ) )
            {
            // InternalEOCL.g:6336:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 ) )
            // InternalEOCL.g:6337:2: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0_0()); 
            }
            // InternalEOCL.g:6338:2: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 )
            // InternalEOCL.g:6338:3: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0
            {
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0__1"
    // InternalEOCL.g:6346:1: rule__CurlyBracketedClauseCS__Group_2_0__1 : rule__CurlyBracketedClauseCS__Group_2_0__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6350:1: ( rule__CurlyBracketedClauseCS__Group_2_0__1__Impl )
            // InternalEOCL.g:6351:2: rule__CurlyBracketedClauseCS__Group_2_0__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_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__CurlyBracketedClauseCS__Group_2_0__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0__1__Impl"
    // InternalEOCL.g:6357:1: rule__CurlyBracketedClauseCS__Group_2_0__1__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )* ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6361:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )* ) )
            // InternalEOCL.g:6362:1: ( ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )* )
            {
            // InternalEOCL.g:6362:1: ( ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )* )
            // InternalEOCL.g:6363:2: ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_0_1()); 
            }
            // InternalEOCL.g:6364:2: ( rule__CurlyBracketedClauseCS__Group_2_0_1__0 )*
            loop56:
            do {
                int alt56=2;
                int LA56_0 = input.LA(1);

                if ( (LA56_0==55) ) {
                    alt56=1;
                }


                switch (alt56) {
            	case 1 :
            	    // InternalEOCL.g:6364:3: rule__CurlyBracketedClauseCS__Group_2_0_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__CurlyBracketedClauseCS__Group_2_0_1__0();

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

            	    }
            	    break;

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

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0_1__0"
    // InternalEOCL.g:6373:1: rule__CurlyBracketedClauseCS__Group_2_0_1__0 : rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_0_1__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6377:1: ( rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_0_1__1 )
            // InternalEOCL.g:6378:2: rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_0_1__1
            {
            pushFollow(FOLLOW_7);
            rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_0_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_0_1__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl"
    // InternalEOCL.g:6385:1: rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl : ( ',' ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6389:1: ( ( ',' ) )
            // InternalEOCL.g:6390:1: ( ',' )
            {
            // InternalEOCL.g:6390:1: ( ',' )
            // InternalEOCL.g:6391:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_0_1_0()); 
            }
            match(input,55,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_0_1_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0_1__1"
    // InternalEOCL.g:6400:1: rule__CurlyBracketedClauseCS__Group_2_0_1__1 : rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6404:1: ( rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl )
            // InternalEOCL.g:6405:2: rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_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__CurlyBracketedClauseCS__Group_2_0_1__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl"
    // InternalEOCL.g:6411:1: rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6415:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 ) ) )
            // InternalEOCL.g:6416:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 ) )
            {
            // InternalEOCL.g:6416:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 ) )
            // InternalEOCL.g:6417:2: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0_1_1()); 
            }
            // InternalEOCL.g:6418:2: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 )
            // InternalEOCL.g:6418:3: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1
            {
            pushFollow(FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__0"
    // InternalEOCL.g:6427: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 {
            // InternalEOCL.g:6431:1: ( rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 )
            // InternalEOCL.g:6432:2: rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__RoundBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6439:1: rule__RoundBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__RoundBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6443:1: ( ( () ) )
            // InternalEOCL.g:6444:1: ( () )
            {
            // InternalEOCL.g:6444:1: ( () )
            // InternalEOCL.g:6445:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0()); 
            }
            // InternalEOCL.g:6446:2: ()
            // InternalEOCL.g:6446:3: 
            {
            }

            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"
    // InternalEOCL.g:6454: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 {
            // InternalEOCL.g:6458:1: ( rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 )
            // InternalEOCL.g:6459:2: rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2
            {
            pushFollow(FOLLOW_33);
            rule__RoundBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6466:1: rule__RoundBracketedClauseCS__Group__1__Impl : ( '(' ) ;
    public final void rule__RoundBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6470:1: ( ( '(' ) )
            // InternalEOCL.g:6471:1: ( '(' )
            {
            // InternalEOCL.g:6471:1: ( '(' )
            // InternalEOCL.g:6472:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1()); 
            }
            match(input,53,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"
    // InternalEOCL.g:6481: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 {
            // InternalEOCL.g:6485:1: ( rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 )
            // InternalEOCL.g:6486:2: rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3
            {
            pushFollow(FOLLOW_33);
            rule__RoundBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6493: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 {
            // InternalEOCL.g:6497:1: ( ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) )
            // InternalEOCL.g:6498:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            {
            // InternalEOCL.g:6498:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            // InternalEOCL.g:6499:2: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:6500:2: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            int alt57=2;
            int LA57_0 = input.LA(1);

            if ( ((LA57_0>=RULE_INT && LA57_0<=RULE_ESCAPED_ID)||(LA57_0>=16 && LA57_0<=18)||(LA57_0>=35 && LA57_0<=49)||LA57_0==53||LA57_0==56||LA57_0==61||(LA57_0>=63 && LA57_0<=64)||LA57_0==69||(LA57_0>=74 && LA57_0<=75)||(LA57_0>=79 && LA57_0<=80)) ) {
                alt57=1;
            }
            switch (alt57) {
                case 1 :
                    // InternalEOCL.g:6500:3: rule__RoundBracketedClauseCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:6508:1: rule__RoundBracketedClauseCS__Group__3 : rule__RoundBracketedClauseCS__Group__3__Impl ;
    public final void rule__RoundBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6512:1: ( rule__RoundBracketedClauseCS__Group__3__Impl )
            // InternalEOCL.g:6513:2: rule__RoundBracketedClauseCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6519:1: rule__RoundBracketedClauseCS__Group__3__Impl : ( ')' ) ;
    public final void rule__RoundBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6523:1: ( ( ')' ) )
            // InternalEOCL.g:6524:1: ( ')' )
            {
            // InternalEOCL.g:6524:1: ( ')' )
            // InternalEOCL.g:6525:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3()); 
            }
            match(input,54,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"
    // InternalEOCL.g:6535: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 {
            // InternalEOCL.g:6539:1: ( rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 )
            // InternalEOCL.g:6540:2: rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1
            {
            pushFollow(FOLLOW_34);
            rule__RoundBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6547: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 {
            // InternalEOCL.g:6551:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) )
            // InternalEOCL.g:6552:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            {
            // InternalEOCL.g:6552:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            // InternalEOCL.g:6553:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0()); 
            }
            // InternalEOCL.g:6554:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            // InternalEOCL.g:6554:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0
            {
            pushFollow(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"
    // InternalEOCL.g:6562:1: rule__RoundBracketedClauseCS__Group_2__1 : rule__RoundBracketedClauseCS__Group_2__1__Impl rule__RoundBracketedClauseCS__Group_2__2 ;
    public final void rule__RoundBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6566:1: ( rule__RoundBracketedClauseCS__Group_2__1__Impl rule__RoundBracketedClauseCS__Group_2__2 )
            // InternalEOCL.g:6567:2: rule__RoundBracketedClauseCS__Group_2__1__Impl rule__RoundBracketedClauseCS__Group_2__2
            {
            pushFollow(FOLLOW_34);
            rule__RoundBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__2();

            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"
    // InternalEOCL.g:6574: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 {
            // InternalEOCL.g:6578:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) )
            // InternalEOCL.g:6579:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            {
            // InternalEOCL.g:6579:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            // InternalEOCL.g:6580:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1()); 
            }
            // InternalEOCL.g:6581:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            loop58:
            do {
                int alt58=2;
                int LA58_0 = input.LA(1);

                if ( (LA58_0==55) ) {
                    alt58=1;
                }


                switch (alt58) {
            	case 1 :
            	    // InternalEOCL.g:6581:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1();

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

            	    }
            	    break;

            	default :
            	    break loop58;
                }
            } 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__RoundBracketedClauseCS__Group_2__2"
    // InternalEOCL.g:6589:1: rule__RoundBracketedClauseCS__Group_2__2 : rule__RoundBracketedClauseCS__Group_2__2__Impl rule__RoundBracketedClauseCS__Group_2__3 ;
    public final void rule__RoundBracketedClauseCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6593:1: ( rule__RoundBracketedClauseCS__Group_2__2__Impl rule__RoundBracketedClauseCS__Group_2__3 )
            // InternalEOCL.g:6594:2: rule__RoundBracketedClauseCS__Group_2__2__Impl rule__RoundBracketedClauseCS__Group_2__3
            {
            pushFollow(FOLLOW_34);
            rule__RoundBracketedClauseCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__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__2"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__2__Impl"
    // InternalEOCL.g:6601:1: rule__RoundBracketedClauseCS__Group_2__2__Impl : ( ( rule__RoundBracketedClauseCS__Group_2_2__0 )? ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6605:1: ( ( ( rule__RoundBracketedClauseCS__Group_2_2__0 )? ) )
            // InternalEOCL.g:6606:1: ( ( rule__RoundBracketedClauseCS__Group_2_2__0 )? )
            {
            // InternalEOCL.g:6606:1: ( ( rule__RoundBracketedClauseCS__Group_2_2__0 )? )
            // InternalEOCL.g:6607:2: ( rule__RoundBracketedClauseCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2_2()); 
            }
            // InternalEOCL.g:6608:2: ( rule__RoundBracketedClauseCS__Group_2_2__0 )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==83) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // InternalEOCL.g:6608:3: rule__RoundBracketedClauseCS__Group_2_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__RoundBracketedClauseCS__Group_2_2__0();

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

                    }
                    break;

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__3"
    // InternalEOCL.g:6616:1: rule__RoundBracketedClauseCS__Group_2__3 : rule__RoundBracketedClauseCS__Group_2__3__Impl ;
    public final void rule__RoundBracketedClauseCS__Group_2__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6620:1: ( rule__RoundBracketedClauseCS__Group_2__3__Impl )
            // InternalEOCL.g:6621:2: rule__RoundBracketedClauseCS__Group_2__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__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_2__3"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__3__Impl"
    // InternalEOCL.g:6627:1: rule__RoundBracketedClauseCS__Group_2__3__Impl : ( ( rule__RoundBracketedClauseCS__Group_2_3__0 )* ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6631:1: ( ( ( rule__RoundBracketedClauseCS__Group_2_3__0 )* ) )
            // InternalEOCL.g:6632:1: ( ( rule__RoundBracketedClauseCS__Group_2_3__0 )* )
            {
            // InternalEOCL.g:6632:1: ( ( rule__RoundBracketedClauseCS__Group_2_3__0 )* )
            // InternalEOCL.g:6633:2: ( rule__RoundBracketedClauseCS__Group_2_3__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2_3()); 
            }
            // InternalEOCL.g:6634:2: ( rule__RoundBracketedClauseCS__Group_2_3__0 )*
            loop60:
            do {
                int alt60=2;
                int LA60_0 = input.LA(1);

                if ( (LA60_0==82) ) {
                    alt60=1;
                }


                switch (alt60) {
            	case 1 :
            	    // InternalEOCL.g:6634:3: rule__RoundBracketedClauseCS__Group_2_3__0
            	    {
            	    pushFollow(FOLLOW_35);
            	    rule__RoundBracketedClauseCS__Group_2_3__0();

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

            	    }
            	    break;

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

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_2__0"
    // InternalEOCL.g:6643:1: rule__RoundBracketedClauseCS__Group_2_2__0 : rule__RoundBracketedClauseCS__Group_2_2__0__Impl rule__RoundBracketedClauseCS__Group_2_2__1 ;
    public final void rule__RoundBracketedClauseCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6647:1: ( rule__RoundBracketedClauseCS__Group_2_2__0__Impl rule__RoundBracketedClauseCS__Group_2_2__1 )
            // InternalEOCL.g:6648:2: rule__RoundBracketedClauseCS__Group_2_2__0__Impl rule__RoundBracketedClauseCS__Group_2_2__1
            {
            pushFollow(FOLLOW_9);
            rule__RoundBracketedClauseCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__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__RoundBracketedClauseCS__Group_2_2__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_2__0__Impl"
    // InternalEOCL.g:6655:1: rule__RoundBracketedClauseCS__Group_2_2__0__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6659:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 ) ) )
            // InternalEOCL.g:6660:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 ) )
            {
            // InternalEOCL.g:6660:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 ) )
            // InternalEOCL.g:6661:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_2_0()); 
            }
            // InternalEOCL.g:6662:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 )
            // InternalEOCL.g:6662:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0
            {
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_2__1"
    // InternalEOCL.g:6670:1: rule__RoundBracketedClauseCS__Group_2_2__1 : rule__RoundBracketedClauseCS__Group_2_2__1__Impl ;
    public final void rule__RoundBracketedClauseCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6674:1: ( rule__RoundBracketedClauseCS__Group_2_2__1__Impl )
            // InternalEOCL.g:6675:2: rule__RoundBracketedClauseCS__Group_2_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__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__RoundBracketedClauseCS__Group_2_2__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_2__1__Impl"
    // InternalEOCL.g:6681:1: rule__RoundBracketedClauseCS__Group_2_2__1__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )* ) ;
    public final void rule__RoundBracketedClauseCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6685:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )* ) )
            // InternalEOCL.g:6686:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )* )
            {
            // InternalEOCL.g:6686:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )* )
            // InternalEOCL.g:6687:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_2_1()); 
            }
            // InternalEOCL.g:6688:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 )*
            loop61:
            do {
                int alt61=2;
                int LA61_0 = input.LA(1);

                if ( (LA61_0==55) ) {
                    alt61=1;
                }


                switch (alt61) {
            	case 1 :
            	    // InternalEOCL.g:6688:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1();

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

            	    }
            	    break;

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

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_3__0"
    // InternalEOCL.g:6697:1: rule__RoundBracketedClauseCS__Group_2_3__0 : rule__RoundBracketedClauseCS__Group_2_3__0__Impl rule__RoundBracketedClauseCS__Group_2_3__1 ;
    public final void rule__RoundBracketedClauseCS__Group_2_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6701:1: ( rule__RoundBracketedClauseCS__Group_2_3__0__Impl rule__RoundBracketedClauseCS__Group_2_3__1 )
            // InternalEOCL.g:6702:2: rule__RoundBracketedClauseCS__Group_2_3__0__Impl rule__RoundBracketedClauseCS__Group_2_3__1
            {
            pushFollow(FOLLOW_9);
            rule__RoundBracketedClauseCS__Group_2_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2_3__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_3__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_3__0__Impl"
    // InternalEOCL.g:6709:1: rule__RoundBracketedClauseCS__Group_2_3__0__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__Group_2_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6713:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 ) ) )
            // InternalEOCL.g:6714:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 ) )
            {
            // InternalEOCL.g:6714:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 ) )
            // InternalEOCL.g:6715:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_3_0()); 
            }
            // InternalEOCL.g:6716:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 )
            // InternalEOCL.g:6716:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0
            {
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_3__1"
    // InternalEOCL.g:6724:1: rule__RoundBracketedClauseCS__Group_2_3__1 : rule__RoundBracketedClauseCS__Group_2_3__1__Impl ;
    public final void rule__RoundBracketedClauseCS__Group_2_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6728:1: ( rule__RoundBracketedClauseCS__Group_2_3__1__Impl )
            // InternalEOCL.g:6729:2: rule__RoundBracketedClauseCS__Group_2_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2_3__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_3__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2_3__1__Impl"
    // InternalEOCL.g:6735:1: rule__RoundBracketedClauseCS__Group_2_3__1__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )* ) ;
    public final void rule__RoundBracketedClauseCS__Group_2_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6739:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )* ) )
            // InternalEOCL.g:6740:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )* )
            {
            // InternalEOCL.g:6740:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )* )
            // InternalEOCL.g:6741:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_3_1()); 
            }
            // InternalEOCL.g:6742:2: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 )*
            loop62:
            do {
                int alt62=2;
                int LA62_0 = input.LA(1);

                if ( (LA62_0==55) ) {
                    alt62=1;
                }


                switch (alt62) {
            	case 1 :
            	    // InternalEOCL.g:6742:3: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1();

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

            	    }
            	    break;

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

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__0"
    // InternalEOCL.g:6751: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 {
            // InternalEOCL.g:6755:1: ( rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 )
            // InternalEOCL.g:6756:2: rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__SquareBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6763:1: rule__SquareBracketedClauseCS__Group__0__Impl : ( '[' ) ;
    public final void rule__SquareBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6767:1: ( ( '[' ) )
            // InternalEOCL.g:6768:1: ( '[' )
            {
            // InternalEOCL.g:6768:1: ( '[' )
            // InternalEOCL.g:6769:2: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0()); 
            }
            match(input,66,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"
    // InternalEOCL.g:6778: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 {
            // InternalEOCL.g:6782:1: ( rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 )
            // InternalEOCL.g:6783:2: rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2
            {
            pushFollow(FOLLOW_36);
            rule__SquareBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6790:1: rule__SquareBracketedClauseCS__Group__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) ;
    public final void rule__SquareBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6794:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) )
            // InternalEOCL.g:6795:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            {
            // InternalEOCL.g:6795:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            // InternalEOCL.g:6796:2: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1()); 
            }
            // InternalEOCL.g:6797:2: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            // InternalEOCL.g:6797:3: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:6805: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 {
            // InternalEOCL.g:6809:1: ( rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 )
            // InternalEOCL.g:6810:2: rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3
            {
            pushFollow(FOLLOW_36);
            rule__SquareBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6817: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 {
            // InternalEOCL.g:6821:1: ( ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) )
            // InternalEOCL.g:6822:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            {
            // InternalEOCL.g:6822:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            // InternalEOCL.g:6823:2: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:6824:2: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            loop63:
            do {
                int alt63=2;
                int LA63_0 = input.LA(1);

                if ( (LA63_0==55) ) {
                    alt63=1;
                }


                switch (alt63) {
            	case 1 :
            	    // InternalEOCL.g:6824:3: rule__SquareBracketedClauseCS__Group_2__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__SquareBracketedClauseCS__Group_2__0();

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

            	    }
            	    break;

            	default :
            	    break loop63;
                }
            } 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"
    // InternalEOCL.g:6832:1: rule__SquareBracketedClauseCS__Group__3 : rule__SquareBracketedClauseCS__Group__3__Impl ;
    public final void rule__SquareBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6836:1: ( rule__SquareBracketedClauseCS__Group__3__Impl )
            // InternalEOCL.g:6837:2: rule__SquareBracketedClauseCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6843:1: rule__SquareBracketedClauseCS__Group__3__Impl : ( ']' ) ;
    public final void rule__SquareBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6847:1: ( ( ']' ) )
            // InternalEOCL.g:6848:1: ( ']' )
            {
            // InternalEOCL.g:6848:1: ( ']' )
            // InternalEOCL.g:6849:2: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3()); 
            }
            match(input,67,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"
    // InternalEOCL.g:6859: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 {
            // InternalEOCL.g:6863:1: ( rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 )
            // InternalEOCL.g:6864:2: rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1
            {
            pushFollow(FOLLOW_4);
            rule__SquareBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6871:1: rule__SquareBracketedClauseCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__SquareBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6875:1: ( ( ',' ) )
            // InternalEOCL.g:6876:1: ( ',' )
            {
            // InternalEOCL.g:6876:1: ( ',' )
            // InternalEOCL.g:6877:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:6886: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 {
            // InternalEOCL.g:6890:1: ( rule__SquareBracketedClauseCS__Group_2__1__Impl )
            // InternalEOCL.g:6891:2: rule__SquareBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6897: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 {
            // InternalEOCL.g:6901:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) )
            // InternalEOCL.g:6902:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            {
            // InternalEOCL.g:6902:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            // InternalEOCL.g:6903:2: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1()); 
            }
            // InternalEOCL.g:6904:2: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            // InternalEOCL.g:6904:3: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:6913: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 {
            // InternalEOCL.g:6917:1: ( rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 )
            // InternalEOCL.g:6918:2: rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1
            {
            pushFollow(FOLLOW_37);
            rule__NavigatingArgCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6925: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 {
            // InternalEOCL.g:6929:1: ( ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) )
            // InternalEOCL.g:6930:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            {
            // InternalEOCL.g:6930:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            // InternalEOCL.g:6931:2: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0()); 
            }
            // InternalEOCL.g:6932:2: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            // InternalEOCL.g:6932:3: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0
            {
            pushFollow(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"
    // InternalEOCL.g:6940: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 {
            // InternalEOCL.g:6944:1: ( rule__NavigatingArgCS__Group_0__1__Impl )
            // InternalEOCL.g:6945:2: rule__NavigatingArgCS__Group_0__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:6951: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 {
            // InternalEOCL.g:6955:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) )
            // InternalEOCL.g:6956:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            {
            // InternalEOCL.g:6956:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            // InternalEOCL.g:6957:2: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1()); 
            }
            // InternalEOCL.g:6958:2: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( (LA64_0==56||LA64_0==68) ) {
                alt64=1;
            }
            switch (alt64) {
                case 1 :
                    // InternalEOCL.g:6958:3: rule__NavigatingArgCS__Alternatives_0_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:6967: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 {
            // InternalEOCL.g:6971:1: ( rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 )
            // InternalEOCL.g:6972:2: rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1
            {
            pushFollow(FOLLOW_7);
            rule__NavigatingArgCS__Group_0_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:6979:1: rule__NavigatingArgCS__Group_0_1_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:6983:1: ( ( ':' ) )
            // InternalEOCL.g:6984:1: ( ':' )
            {
            // InternalEOCL.g:6984:1: ( ':' )
            // InternalEOCL.g:6985:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_0_0()); 
            }
            match(input,56,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_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"
    // InternalEOCL.g:6994: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 {
            // InternalEOCL.g:6998:1: ( rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 )
            // InternalEOCL.g:6999:2: rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2
            {
            pushFollow(FOLLOW_18);
            rule__NavigatingArgCS__Group_0_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7006:1: rule__NavigatingArgCS__Group_0_1_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7010:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 ) ) )
            // InternalEOCL.g:7011:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 ) )
            {
            // InternalEOCL.g:7011:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 ) )
            // InternalEOCL.g:7012:2: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_0_1()); 
            }
            // InternalEOCL.g:7013:2: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 )
            // InternalEOCL.g:7013:3: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_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"
    // InternalEOCL.g:7021: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 {
            // InternalEOCL.g:7025:1: ( rule__NavigatingArgCS__Group_0_1_0__2__Impl )
            // InternalEOCL.g:7026:2: rule__NavigatingArgCS__Group_0_1_0__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7032: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 {
            // InternalEOCL.g:7036:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) )
            // InternalEOCL.g:7037:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            {
            // InternalEOCL.g:7037:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            // InternalEOCL.g:7038:2: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2()); 
            }
            // InternalEOCL.g:7039:2: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            int alt65=2;
            int LA65_0 = input.LA(1);

            if ( (LA65_0==25) ) {
                alt65=1;
            }
            switch (alt65) {
                case 1 :
                    // InternalEOCL.g:7039:3: rule__NavigatingArgCS__Group_0_1_0_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7048: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 {
            // InternalEOCL.g:7052:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 )
            // InternalEOCL.g:7053:2: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingArgCS__Group_0_1_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7060: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 {
            // InternalEOCL.g:7064:1: ( ( '=' ) )
            // InternalEOCL.g:7065:1: ( '=' )
            {
            // InternalEOCL.g:7065:1: ( '=' )
            // InternalEOCL.g:7066:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0()); 
            }
            match(input,25,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"
    // InternalEOCL.g:7075: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 {
            // InternalEOCL.g:7079:1: ( rule__NavigatingArgCS__Group_0_1_0_2__1__Impl )
            // InternalEOCL.g:7080:2: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7086: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 {
            // InternalEOCL.g:7090:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) )
            // InternalEOCL.g:7091:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            {
            // InternalEOCL.g:7091:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            // InternalEOCL.g:7092:2: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1()); 
            }
            // InternalEOCL.g:7093:2: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            // InternalEOCL.g:7093:3: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:7102: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 {
            // InternalEOCL.g:7106:1: ( rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 )
            // InternalEOCL.g:7107:2: rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingArgCS__Group_0_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7114:1: rule__NavigatingArgCS__Group_0_1_1__0__Impl : ( 'in' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7118:1: ( ( 'in' ) )
            // InternalEOCL.g:7119:1: ( 'in' )
            {
            // InternalEOCL.g:7119:1: ( 'in' )
            // InternalEOCL.g:7120:2: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_1_0()); 
            }
            match(input,68,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getInKeyword_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"
    // InternalEOCL.g:7129:1: rule__NavigatingArgCS__Group_0_1_1__1 : rule__NavigatingArgCS__Group_0_1_1__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7133:1: ( rule__NavigatingArgCS__Group_0_1_1__1__Impl )
            // InternalEOCL.g:7134:2: rule__NavigatingArgCS__Group_0_1_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingArgCS__Group_0_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__NavigatingArgCS__Group_0_1_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1__Impl"
    // InternalEOCL.g:7140:1: rule__NavigatingArgCS__Group_0_1_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7144:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 ) ) )
            // InternalEOCL.g:7145:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 ) )
            {
            // InternalEOCL.g:7145:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 ) )
            // InternalEOCL.g:7146:2: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_1()); 
            }
            // InternalEOCL.g:7147:2: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 )
            // InternalEOCL.g:7147:3: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_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_1__0"
    // InternalEOCL.g:7156: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 {
            // InternalEOCL.g:7160:1: ( rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 )
            // InternalEOCL.g:7161:2: rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__NavigatingArgCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7168:1: rule__NavigatingArgCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7172:1: ( ( ':' ) )
            // InternalEOCL.g:7173:1: ( ':' )
            {
            // InternalEOCL.g:7173:1: ( ':' )
            // InternalEOCL.g:7174:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0()); 
            }
            match(input,56,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"
    // InternalEOCL.g:7183: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 {
            // InternalEOCL.g:7187:1: ( rule__NavigatingArgCS__Group_1__1__Impl )
            // InternalEOCL.g:7188:2: rule__NavigatingArgCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7194: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 {
            // InternalEOCL.g:7198:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalEOCL.g:7199:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalEOCL.g:7199:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            // InternalEOCL.g:7200:2: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1()); 
            }
            // InternalEOCL.g:7201:2: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            // InternalEOCL.g:7201:3: rule__NavigatingArgCS__OwnedTypeAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:7210: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 {
            // InternalEOCL.g:7214:1: ( rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 )
            // InternalEOCL.g:7215:2: rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingBarArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7222:1: rule__NavigatingBarArgCS__Group__0__Impl : ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7226:1: ( ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) )
            // InternalEOCL.g:7227:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            {
            // InternalEOCL.g:7227:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            // InternalEOCL.g:7228:2: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0()); 
            }
            // InternalEOCL.g:7229:2: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            // InternalEOCL.g:7229:3: rule__NavigatingBarArgCS__PrefixAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:7237: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 {
            // InternalEOCL.g:7241:1: ( rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 )
            // InternalEOCL.g:7242:2: rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2
            {
            pushFollow(FOLLOW_12);
            rule__NavigatingBarArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7249:1: rule__NavigatingBarArgCS__Group__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7253:1: ( ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEOCL.g:7254:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEOCL.g:7254:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEOCL.g:7255:2: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1()); 
            }
            // InternalEOCL.g:7256:2: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEOCL.g:7256:3: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:7264:1: rule__NavigatingBarArgCS__Group__2 : rule__NavigatingBarArgCS__Group__2__Impl ;
    public final void rule__NavigatingBarArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7268:1: ( rule__NavigatingBarArgCS__Group__2__Impl )
            // InternalEOCL.g:7269:2: rule__NavigatingBarArgCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7275: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 {
            // InternalEOCL.g:7279:1: ( ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) )
            // InternalEOCL.g:7280:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            {
            // InternalEOCL.g:7280:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            // InternalEOCL.g:7281:2: ( rule__NavigatingBarArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:7282:2: ( rule__NavigatingBarArgCS__Group_2__0 )?
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( (LA66_0==56) ) {
                alt66=1;
            }
            switch (alt66) {
                case 1 :
                    // InternalEOCL.g:7282:3: rule__NavigatingBarArgCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7291: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 {
            // InternalEOCL.g:7295:1: ( rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 )
            // InternalEOCL.g:7296:2: rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1
            {
            pushFollow(FOLLOW_7);
            rule__NavigatingBarArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7303:1: rule__NavigatingBarArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingBarArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7307:1: ( ( ':' ) )
            // InternalEOCL.g:7308:1: ( ':' )
            {
            // InternalEOCL.g:7308:1: ( ':' )
            // InternalEOCL.g:7309:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0()); 
            }
            match(input,56,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"
    // InternalEOCL.g:7318: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 {
            // InternalEOCL.g:7322:1: ( rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 )
            // InternalEOCL.g:7323:2: rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2
            {
            pushFollow(FOLLOW_18);
            rule__NavigatingBarArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7330: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 {
            // InternalEOCL.g:7334:1: ( ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEOCL.g:7335:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEOCL.g:7335:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalEOCL.g:7336:2: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1()); 
            }
            // InternalEOCL.g:7337:2: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            // InternalEOCL.g:7337:3: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:7345: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 {
            // InternalEOCL.g:7349:1: ( rule__NavigatingBarArgCS__Group_2__2__Impl )
            // InternalEOCL.g:7350:2: rule__NavigatingBarArgCS__Group_2__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7356: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 {
            // InternalEOCL.g:7360:1: ( ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) )
            // InternalEOCL.g:7361:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            {
            // InternalEOCL.g:7361:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            // InternalEOCL.g:7362:2: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2()); 
            }
            // InternalEOCL.g:7363:2: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( (LA67_0==25) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // InternalEOCL.g:7363:3: rule__NavigatingBarArgCS__Group_2_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7372: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 {
            // InternalEOCL.g:7376:1: ( rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 )
            // InternalEOCL.g:7377:2: rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingBarArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7384:1: rule__NavigatingBarArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingBarArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7388:1: ( ( '=' ) )
            // InternalEOCL.g:7389:1: ( '=' )
            {
            // InternalEOCL.g:7389:1: ( '=' )
            // InternalEOCL.g:7390:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0()); 
            }
            match(input,25,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"
    // InternalEOCL.g:7399: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 {
            // InternalEOCL.g:7403:1: ( rule__NavigatingBarArgCS__Group_2_2__1__Impl )
            // InternalEOCL.g:7404:2: rule__NavigatingBarArgCS__Group_2_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7410: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 {
            // InternalEOCL.g:7414:1: ( ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalEOCL.g:7415:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalEOCL.g:7415:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalEOCL.g:7416:2: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); 
            }
            // InternalEOCL.g:7417:2: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalEOCL.g:7417:3: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:7426: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 {
            // InternalEOCL.g:7430:1: ( rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 )
            // InternalEOCL.g:7431:2: rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingCommaArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7438:1: rule__NavigatingCommaArgCS__Group__0__Impl : ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7442:1: ( ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) )
            // InternalEOCL.g:7443:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            {
            // InternalEOCL.g:7443:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            // InternalEOCL.g:7444:2: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0()); 
            }
            // InternalEOCL.g:7445:2: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            // InternalEOCL.g:7445:3: rule__NavigatingCommaArgCS__PrefixAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:7453: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 {
            // InternalEOCL.g:7457:1: ( rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 )
            // InternalEOCL.g:7458:2: rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2
            {
            pushFollow(FOLLOW_37);
            rule__NavigatingCommaArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7465:1: rule__NavigatingCommaArgCS__Group__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7469:1: ( ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEOCL.g:7470:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEOCL.g:7470:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEOCL.g:7471:2: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1()); 
            }
            // InternalEOCL.g:7472:2: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEOCL.g:7472:3: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:7480:1: rule__NavigatingCommaArgCS__Group__2 : rule__NavigatingCommaArgCS__Group__2__Impl ;
    public final void rule__NavigatingCommaArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7484:1: ( rule__NavigatingCommaArgCS__Group__2__Impl )
            // InternalEOCL.g:7485:2: rule__NavigatingCommaArgCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7491:1: rule__NavigatingCommaArgCS__Group__2__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7495:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) )
            // InternalEOCL.g:7496:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            {
            // InternalEOCL.g:7496:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            // InternalEOCL.g:7497:2: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2()); 
            }
            // InternalEOCL.g:7498:2: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            int alt68=2;
            int LA68_0 = input.LA(1);

            if ( (LA68_0==56||LA68_0==68) ) {
                alt68=1;
            }
            switch (alt68) {
                case 1 :
                    // InternalEOCL.g:7498:3: rule__NavigatingCommaArgCS__Alternatives_2
                    {
                    pushFollow(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"
    // InternalEOCL.g:7507: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 {
            // InternalEOCL.g:7511:1: ( rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 )
            // InternalEOCL.g:7512:2: rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1
            {
            pushFollow(FOLLOW_7);
            rule__NavigatingCommaArgCS__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7519:1: rule__NavigatingCommaArgCS__Group_2_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7523:1: ( ( ':' ) )
            // InternalEOCL.g:7524:1: ( ':' )
            {
            // InternalEOCL.g:7524:1: ( ':' )
            // InternalEOCL.g:7525:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_0_0()); 
            }
            match(input,56,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_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"
    // InternalEOCL.g:7534: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 {
            // InternalEOCL.g:7538:1: ( rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 )
            // InternalEOCL.g:7539:2: rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2
            {
            pushFollow(FOLLOW_18);
            rule__NavigatingCommaArgCS__Group_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7546:1: rule__NavigatingCommaArgCS__Group_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7550:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 ) ) )
            // InternalEOCL.g:7551:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 ) )
            {
            // InternalEOCL.g:7551:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 ) )
            // InternalEOCL.g:7552:2: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_0_1()); 
            }
            // InternalEOCL.g:7553:2: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 )
            // InternalEOCL.g:7553:3: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_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"
    // InternalEOCL.g:7561: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 {
            // InternalEOCL.g:7565:1: ( rule__NavigatingCommaArgCS__Group_2_0__2__Impl )
            // InternalEOCL.g:7566:2: rule__NavigatingCommaArgCS__Group_2_0__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7572: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 {
            // InternalEOCL.g:7576:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) )
            // InternalEOCL.g:7577:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            {
            // InternalEOCL.g:7577:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            // InternalEOCL.g:7578:2: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2()); 
            }
            // InternalEOCL.g:7579:2: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            int alt69=2;
            int LA69_0 = input.LA(1);

            if ( (LA69_0==25) ) {
                alt69=1;
            }
            switch (alt69) {
                case 1 :
                    // InternalEOCL.g:7579:3: rule__NavigatingCommaArgCS__Group_2_0_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7588: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 {
            // InternalEOCL.g:7592:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 )
            // InternalEOCL.g:7593:2: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7600: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 {
            // InternalEOCL.g:7604:1: ( ( '=' ) )
            // InternalEOCL.g:7605:1: ( '=' )
            {
            // InternalEOCL.g:7605:1: ( '=' )
            // InternalEOCL.g:7606:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0()); 
            }
            match(input,25,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"
    // InternalEOCL.g:7615: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 {
            // InternalEOCL.g:7619:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl )
            // InternalEOCL.g:7620:2: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7626: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 {
            // InternalEOCL.g:7630:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) )
            // InternalEOCL.g:7631:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            {
            // InternalEOCL.g:7631:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            // InternalEOCL.g:7632:2: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1()); 
            }
            // InternalEOCL.g:7633:2: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            // InternalEOCL.g:7633:3: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:7642: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 {
            // InternalEOCL.g:7646:1: ( rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 )
            // InternalEOCL.g:7647:2: rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingCommaArgCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7654:1: rule__NavigatingCommaArgCS__Group_2_1__0__Impl : ( 'in' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7658:1: ( ( 'in' ) )
            // InternalEOCL.g:7659:1: ( 'in' )
            {
            // InternalEOCL.g:7659:1: ( 'in' )
            // InternalEOCL.g:7660:2: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_1_0()); 
            }
            match(input,68,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_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"
    // InternalEOCL.g:7669:1: rule__NavigatingCommaArgCS__Group_2_1__1 : rule__NavigatingCommaArgCS__Group_2_1__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7673:1: ( rule__NavigatingCommaArgCS__Group_2_1__1__Impl )
            // InternalEOCL.g:7674:2: rule__NavigatingCommaArgCS__Group_2_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingCommaArgCS__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__NavigatingCommaArgCS__Group_2_1__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1__Impl"
    // InternalEOCL.g:7680:1: rule__NavigatingCommaArgCS__Group_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7684:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 ) ) )
            // InternalEOCL.g:7685:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 ) )
            {
            // InternalEOCL.g:7685:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 ) )
            // InternalEOCL.g:7686:2: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_1()); 
            }
            // InternalEOCL.g:7687:2: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 )
            // InternalEOCL.g:7687:3: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1
            {
            pushFollow(FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_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__NavigatingSemiArgCS__Group__0"
    // InternalEOCL.g:7696: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 {
            // InternalEOCL.g:7700:1: ( rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 )
            // InternalEOCL.g:7701:2: rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingSemiArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7708:1: rule__NavigatingSemiArgCS__Group__0__Impl : ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7712:1: ( ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) )
            // InternalEOCL.g:7713:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            {
            // InternalEOCL.g:7713:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            // InternalEOCL.g:7714:2: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0()); 
            }
            // InternalEOCL.g:7715:2: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            // InternalEOCL.g:7715:3: rule__NavigatingSemiArgCS__PrefixAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:7723: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 {
            // InternalEOCL.g:7727:1: ( rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 )
            // InternalEOCL.g:7728:2: rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2
            {
            pushFollow(FOLLOW_12);
            rule__NavigatingSemiArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7735:1: rule__NavigatingSemiArgCS__Group__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7739:1: ( ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalEOCL.g:7740:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalEOCL.g:7740:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalEOCL.g:7741:2: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1()); 
            }
            // InternalEOCL.g:7742:2: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            // InternalEOCL.g:7742:3: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:7750:1: rule__NavigatingSemiArgCS__Group__2 : rule__NavigatingSemiArgCS__Group__2__Impl ;
    public final void rule__NavigatingSemiArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7754:1: ( rule__NavigatingSemiArgCS__Group__2__Impl )
            // InternalEOCL.g:7755:2: rule__NavigatingSemiArgCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7761: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 {
            // InternalEOCL.g:7765:1: ( ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) )
            // InternalEOCL.g:7766:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            {
            // InternalEOCL.g:7766:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            // InternalEOCL.g:7767:2: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:7768:2: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            int alt70=2;
            int LA70_0 = input.LA(1);

            if ( (LA70_0==56) ) {
                alt70=1;
            }
            switch (alt70) {
                case 1 :
                    // InternalEOCL.g:7768:3: rule__NavigatingSemiArgCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7777: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 {
            // InternalEOCL.g:7781:1: ( rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 )
            // InternalEOCL.g:7782:2: rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1
            {
            pushFollow(FOLLOW_7);
            rule__NavigatingSemiArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7789:1: rule__NavigatingSemiArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7793:1: ( ( ':' ) )
            // InternalEOCL.g:7794:1: ( ':' )
            {
            // InternalEOCL.g:7794:1: ( ':' )
            // InternalEOCL.g:7795:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0()); 
            }
            match(input,56,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"
    // InternalEOCL.g:7804: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 {
            // InternalEOCL.g:7808:1: ( rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 )
            // InternalEOCL.g:7809:2: rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2
            {
            pushFollow(FOLLOW_18);
            rule__NavigatingSemiArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7816: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 {
            // InternalEOCL.g:7820:1: ( ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEOCL.g:7821:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEOCL.g:7821:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalEOCL.g:7822:2: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1()); 
            }
            // InternalEOCL.g:7823:2: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            // InternalEOCL.g:7823:3: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:7831: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 {
            // InternalEOCL.g:7835:1: ( rule__NavigatingSemiArgCS__Group_2__2__Impl )
            // InternalEOCL.g:7836:2: rule__NavigatingSemiArgCS__Group_2__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7842: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 {
            // InternalEOCL.g:7846:1: ( ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) )
            // InternalEOCL.g:7847:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            {
            // InternalEOCL.g:7847:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            // InternalEOCL.g:7848:2: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2()); 
            }
            // InternalEOCL.g:7849:2: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( (LA71_0==25) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // InternalEOCL.g:7849:3: rule__NavigatingSemiArgCS__Group_2_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:7858: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 {
            // InternalEOCL.g:7862:1: ( rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 )
            // InternalEOCL.g:7863:2: rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1
            {
            pushFollow(FOLLOW_4);
            rule__NavigatingSemiArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7870:1: rule__NavigatingSemiArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7874:1: ( ( '=' ) )
            // InternalEOCL.g:7875:1: ( '=' )
            {
            // InternalEOCL.g:7875:1: ( '=' )
            // InternalEOCL.g:7876:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0()); 
            }
            match(input,25,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"
    // InternalEOCL.g:7885: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 {
            // InternalEOCL.g:7889:1: ( rule__NavigatingSemiArgCS__Group_2_2__1__Impl )
            // InternalEOCL.g:7890:2: rule__NavigatingSemiArgCS__Group_2_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:7896: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 {
            // InternalEOCL.g:7900:1: ( ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalEOCL.g:7901:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalEOCL.g:7901:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalEOCL.g:7902:2: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1()); 
            }
            // InternalEOCL.g:7903:2: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalEOCL.g:7903:3: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(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__IfExpCS__Group__0"
    // InternalEOCL.g:7912: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 {
            // InternalEOCL.g:7916:1: ( rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 )
            // InternalEOCL.g:7917:2: rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1
            {
            pushFollow(FOLLOW_15);
            rule__IfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7924:1: rule__IfExpCS__Group__0__Impl : ( 'if' ) ;
    public final void rule__IfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7928:1: ( ( 'if' ) )
            // InternalEOCL.g:7929:1: ( 'if' )
            {
            // InternalEOCL.g:7929:1: ( 'if' )
            // InternalEOCL.g:7930:2: 'if'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getIfKeyword_0()); 
            }
            match(input,69,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"
    // InternalEOCL.g:7939: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 {
            // InternalEOCL.g:7943:1: ( rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 )
            // InternalEOCL.g:7944:2: rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2
            {
            pushFollow(FOLLOW_38);
            rule__IfExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7951:1: rule__IfExpCS__Group__1__Impl : ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__IfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7955:1: ( ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalEOCL.g:7956:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalEOCL.g:7956:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            // InternalEOCL.g:7957:2: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1()); 
            }
            // InternalEOCL.g:7958:2: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            // InternalEOCL.g:7958:3: rule__IfExpCS__OwnedConditionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:7966: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 {
            // InternalEOCL.g:7970:1: ( rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 )
            // InternalEOCL.g:7971:2: rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3
            {
            pushFollow(FOLLOW_4);
            rule__IfExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:7978:1: rule__IfExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__IfExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:7982:1: ( ( 'then' ) )
            // InternalEOCL.g:7983:1: ( 'then' )
            {
            // InternalEOCL.g:7983:1: ( 'then' )
            // InternalEOCL.g:7984:2: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getThenKeyword_2()); 
            }
            match(input,70,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"
    // InternalEOCL.g:7993: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 {
            // InternalEOCL.g:7997:1: ( rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 )
            // InternalEOCL.g:7998:2: rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4
            {
            pushFollow(FOLLOW_39);
            rule__IfExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8005:1: rule__IfExpCS__Group__3__Impl : ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__IfExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8009:1: ( ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalEOCL.g:8010:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalEOCL.g:8010:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalEOCL.g:8011:2: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3()); 
            }
            // InternalEOCL.g:8012:2: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            // InternalEOCL.g:8012:3: rule__IfExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(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"
    // InternalEOCL.g:8020: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 {
            // InternalEOCL.g:8024:1: ( rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 )
            // InternalEOCL.g:8025:2: rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5
            {
            pushFollow(FOLLOW_39);
            rule__IfExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8032:1: rule__IfExpCS__Group__4__Impl : ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) ;
    public final void rule__IfExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8036:1: ( ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) )
            // InternalEOCL.g:8037:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            {
            // InternalEOCL.g:8037:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            // InternalEOCL.g:8038:2: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4()); 
            }
            // InternalEOCL.g:8039:2: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            loop72:
            do {
                int alt72=2;
                int LA72_0 = input.LA(1);

                if ( (LA72_0==73) ) {
                    alt72=1;
                }


                switch (alt72) {
            	case 1 :
            	    // InternalEOCL.g:8039:3: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4
            	    {
            	    pushFollow(FOLLOW_40);
            	    rule__IfExpCS__OwnedIfThenExpressionsAssignment_4();

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

            	    }
            	    break;

            	default :
            	    break loop72;
                }
            } 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"
    // InternalEOCL.g:8047: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 {
            // InternalEOCL.g:8051:1: ( rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 )
            // InternalEOCL.g:8052:2: rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6
            {
            pushFollow(FOLLOW_4);
            rule__IfExpCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8059:1: rule__IfExpCS__Group__5__Impl : ( 'else' ) ;
    public final void rule__IfExpCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8063:1: ( ( 'else' ) )
            // InternalEOCL.g:8064:1: ( 'else' )
            {
            // InternalEOCL.g:8064:1: ( 'else' )
            // InternalEOCL.g:8065:2: 'else'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getElseKeyword_5()); 
            }
            match(input,71,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"
    // InternalEOCL.g:8074: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 {
            // InternalEOCL.g:8078:1: ( rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 )
            // InternalEOCL.g:8079:2: rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7
            {
            pushFollow(FOLLOW_41);
            rule__IfExpCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8086:1: rule__IfExpCS__Group__6__Impl : ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) ;
    public final void rule__IfExpCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8090:1: ( ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) )
            // InternalEOCL.g:8091:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            {
            // InternalEOCL.g:8091:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            // InternalEOCL.g:8092:2: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6()); 
            }
            // InternalEOCL.g:8093:2: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            // InternalEOCL.g:8093:3: rule__IfExpCS__OwnedElseExpressionAssignment_6
            {
            pushFollow(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"
    // InternalEOCL.g:8101:1: rule__IfExpCS__Group__7 : rule__IfExpCS__Group__7__Impl ;
    public final void rule__IfExpCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8105:1: ( rule__IfExpCS__Group__7__Impl )
            // InternalEOCL.g:8106:2: rule__IfExpCS__Group__7__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8112:1: rule__IfExpCS__Group__7__Impl : ( 'endif' ) ;
    public final void rule__IfExpCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8116:1: ( ( 'endif' ) )
            // InternalEOCL.g:8117:1: ( 'endif' )
            {
            // InternalEOCL.g:8117:1: ( 'endif' )
            // InternalEOCL.g:8118:2: 'endif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getEndifKeyword_7()); 
            }
            match(input,72,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"
    // InternalEOCL.g:8128: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 {
            // InternalEOCL.g:8132:1: ( rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 )
            // InternalEOCL.g:8133:2: rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__ElseIfThenExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8140:1: rule__ElseIfThenExpCS__Group__0__Impl : ( 'elseif' ) ;
    public final void rule__ElseIfThenExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8144:1: ( ( 'elseif' ) )
            // InternalEOCL.g:8145:1: ( 'elseif' )
            {
            // InternalEOCL.g:8145:1: ( 'elseif' )
            // InternalEOCL.g:8146:2: 'elseif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0()); 
            }
            match(input,73,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"
    // InternalEOCL.g:8155: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 {
            // InternalEOCL.g:8159:1: ( rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 )
            // InternalEOCL.g:8160:2: rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2
            {
            pushFollow(FOLLOW_38);
            rule__ElseIfThenExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8167:1: rule__ElseIfThenExpCS__Group__1__Impl : ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8171:1: ( ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalEOCL.g:8172:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalEOCL.g:8172:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            // InternalEOCL.g:8173:2: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1()); 
            }
            // InternalEOCL.g:8174:2: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            // InternalEOCL.g:8174:3: rule__ElseIfThenExpCS__OwnedConditionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:8182: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 {
            // InternalEOCL.g:8186:1: ( rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 )
            // InternalEOCL.g:8187:2: rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3
            {
            pushFollow(FOLLOW_4);
            rule__ElseIfThenExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8194:1: rule__ElseIfThenExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__ElseIfThenExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8198:1: ( ( 'then' ) )
            // InternalEOCL.g:8199:1: ( 'then' )
            {
            // InternalEOCL.g:8199:1: ( 'then' )
            // InternalEOCL.g:8200:2: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2()); 
            }
            match(input,70,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"
    // InternalEOCL.g:8209:1: rule__ElseIfThenExpCS__Group__3 : rule__ElseIfThenExpCS__Group__3__Impl ;
    public final void rule__ElseIfThenExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8213:1: ( rule__ElseIfThenExpCS__Group__3__Impl )
            // InternalEOCL.g:8214:2: rule__ElseIfThenExpCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8220:1: rule__ElseIfThenExpCS__Group__3__Impl : ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8224:1: ( ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalEOCL.g:8225:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalEOCL.g:8225:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalEOCL.g:8226:2: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3()); 
            }
            // InternalEOCL.g:8227:2: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            // InternalEOCL.g:8227:3: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(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"
    // InternalEOCL.g:8236: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 {
            // InternalEOCL.g:8240:1: ( rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 )
            // InternalEOCL.g:8241:2: rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1
            {
            pushFollow(FOLLOW_7);
            rule__LetExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8248:1: rule__LetExpCS__Group__0__Impl : ( 'let' ) ;
    public final void rule__LetExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8252:1: ( ( 'let' ) )
            // InternalEOCL.g:8253:1: ( 'let' )
            {
            // InternalEOCL.g:8253:1: ( 'let' )
            // InternalEOCL.g:8254:2: 'let'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetKeyword_0()); 
            }
            match(input,74,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"
    // InternalEOCL.g:8263: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 {
            // InternalEOCL.g:8267:1: ( rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 )
            // InternalEOCL.g:8268:2: rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2
            {
            pushFollow(FOLLOW_42);
            rule__LetExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8275:1: rule__LetExpCS__Group__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) ;
    public final void rule__LetExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8279:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) )
            // InternalEOCL.g:8280:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            {
            // InternalEOCL.g:8280:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            // InternalEOCL.g:8281:2: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1()); 
            }
            // InternalEOCL.g:8282:2: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            // InternalEOCL.g:8282:3: rule__LetExpCS__OwnedVariablesAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:8290: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 {
            // InternalEOCL.g:8294:1: ( rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 )
            // InternalEOCL.g:8295:2: rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3
            {
            pushFollow(FOLLOW_42);
            rule__LetExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8302: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 {
            // InternalEOCL.g:8306:1: ( ( ( rule__LetExpCS__Group_2__0 )* ) )
            // InternalEOCL.g:8307:1: ( ( rule__LetExpCS__Group_2__0 )* )
            {
            // InternalEOCL.g:8307:1: ( ( rule__LetExpCS__Group_2__0 )* )
            // InternalEOCL.g:8308:2: ( rule__LetExpCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:8309:2: ( rule__LetExpCS__Group_2__0 )*
            loop73:
            do {
                int alt73=2;
                int LA73_0 = input.LA(1);

                if ( (LA73_0==55) ) {
                    alt73=1;
                }


                switch (alt73) {
            	case 1 :
            	    // InternalEOCL.g:8309:3: rule__LetExpCS__Group_2__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__LetExpCS__Group_2__0();

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

            	    }
            	    break;

            	default :
            	    break loop73;
                }
            } 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"
    // InternalEOCL.g:8317: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 {
            // InternalEOCL.g:8321:1: ( rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 )
            // InternalEOCL.g:8322:2: rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4
            {
            pushFollow(FOLLOW_4);
            rule__LetExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8329:1: rule__LetExpCS__Group__3__Impl : ( 'in' ) ;
    public final void rule__LetExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8333:1: ( ( 'in' ) )
            // InternalEOCL.g:8334:1: ( 'in' )
            {
            // InternalEOCL.g:8334:1: ( 'in' )
            // InternalEOCL.g:8335:2: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInKeyword_3()); 
            }
            match(input,68,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"
    // InternalEOCL.g:8344:1: rule__LetExpCS__Group__4 : rule__LetExpCS__Group__4__Impl ;
    public final void rule__LetExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8348:1: ( rule__LetExpCS__Group__4__Impl )
            // InternalEOCL.g:8349:2: rule__LetExpCS__Group__4__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8355:1: rule__LetExpCS__Group__4__Impl : ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) ;
    public final void rule__LetExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8359:1: ( ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) )
            // InternalEOCL.g:8360:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            {
            // InternalEOCL.g:8360:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            // InternalEOCL.g:8361:2: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4()); 
            }
            // InternalEOCL.g:8362:2: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            // InternalEOCL.g:8362:3: rule__LetExpCS__OwnedInExpressionAssignment_4
            {
            pushFollow(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"
    // InternalEOCL.g:8371: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 {
            // InternalEOCL.g:8375:1: ( rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 )
            // InternalEOCL.g:8376:2: rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1
            {
            pushFollow(FOLLOW_7);
            rule__LetExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8383:1: rule__LetExpCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__LetExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8387:1: ( ( ',' ) )
            // InternalEOCL.g:8388:1: ( ',' )
            {
            // InternalEOCL.g:8388:1: ( ',' )
            // InternalEOCL.g:8389:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:8398: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 {
            // InternalEOCL.g:8402:1: ( rule__LetExpCS__Group_2__1__Impl )
            // InternalEOCL.g:8403:2: rule__LetExpCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8409: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 {
            // InternalEOCL.g:8413:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) )
            // InternalEOCL.g:8414:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            {
            // InternalEOCL.g:8414:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            // InternalEOCL.g:8415:2: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1()); 
            }
            // InternalEOCL.g:8416:2: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            // InternalEOCL.g:8416:3: rule__LetExpCS__OwnedVariablesAssignment_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:8425: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 {
            // InternalEOCL.g:8429:1: ( rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 )
            // InternalEOCL.g:8430:2: rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1
            {
            pushFollow(FOLLOW_43);
            rule__LetVariableCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8437:1: rule__LetVariableCS__Group__0__Impl : ( ( rule__LetVariableCS__NameAssignment_0 ) ) ;
    public final void rule__LetVariableCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8441:1: ( ( ( rule__LetVariableCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:8442:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:8442:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            // InternalEOCL.g:8443:2: ( rule__LetVariableCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:8444:2: ( rule__LetVariableCS__NameAssignment_0 )
            // InternalEOCL.g:8444:3: rule__LetVariableCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:8452: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 {
            // InternalEOCL.g:8456:1: ( rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 )
            // InternalEOCL.g:8457:2: rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2
            {
            pushFollow(FOLLOW_43);
            rule__LetVariableCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8464:1: rule__LetVariableCS__Group__1__Impl : ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) ;
    public final void rule__LetVariableCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8468:1: ( ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) )
            // InternalEOCL.g:8469:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            {
            // InternalEOCL.g:8469:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            // InternalEOCL.g:8470:2: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1()); 
            }
            // InternalEOCL.g:8471:2: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( (LA74_0==53) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // InternalEOCL.g:8471:3: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1
                    {
                    pushFollow(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"
    // InternalEOCL.g:8479: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 {
            // InternalEOCL.g:8483:1: ( rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 )
            // InternalEOCL.g:8484:2: rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3
            {
            pushFollow(FOLLOW_43);
            rule__LetVariableCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8491: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 {
            // InternalEOCL.g:8495:1: ( ( ( rule__LetVariableCS__Group_2__0 )? ) )
            // InternalEOCL.g:8496:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            {
            // InternalEOCL.g:8496:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            // InternalEOCL.g:8497:2: ( rule__LetVariableCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:8498:2: ( rule__LetVariableCS__Group_2__0 )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==56) ) {
                alt75=1;
            }
            switch (alt75) {
                case 1 :
                    // InternalEOCL.g:8498:3: rule__LetVariableCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:8506: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 {
            // InternalEOCL.g:8510:1: ( rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 )
            // InternalEOCL.g:8511:2: rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4
            {
            pushFollow(FOLLOW_4);
            rule__LetVariableCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8518:1: rule__LetVariableCS__Group__3__Impl : ( '=' ) ;
    public final void rule__LetVariableCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8522:1: ( ( '=' ) )
            // InternalEOCL.g:8523:1: ( '=' )
            {
            // InternalEOCL.g:8523:1: ( '=' )
            // InternalEOCL.g:8524:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3()); 
            }
            match(input,25,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"
    // InternalEOCL.g:8533:1: rule__LetVariableCS__Group__4 : rule__LetVariableCS__Group__4__Impl ;
    public final void rule__LetVariableCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8537:1: ( rule__LetVariableCS__Group__4__Impl )
            // InternalEOCL.g:8538:2: rule__LetVariableCS__Group__4__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8544:1: rule__LetVariableCS__Group__4__Impl : ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) ;
    public final void rule__LetVariableCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8548:1: ( ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) )
            // InternalEOCL.g:8549:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            {
            // InternalEOCL.g:8549:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            // InternalEOCL.g:8550:2: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4()); 
            }
            // InternalEOCL.g:8551:2: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            // InternalEOCL.g:8551:3: rule__LetVariableCS__OwnedInitExpressionAssignment_4
            {
            pushFollow(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"
    // InternalEOCL.g:8560: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 {
            // InternalEOCL.g:8564:1: ( rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 )
            // InternalEOCL.g:8565:2: rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1
            {
            pushFollow(FOLLOW_7);
            rule__LetVariableCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8572:1: rule__LetVariableCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__LetVariableCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8576:1: ( ( ':' ) )
            // InternalEOCL.g:8577:1: ( ':' )
            {
            // InternalEOCL.g:8577:1: ( ':' )
            // InternalEOCL.g:8578:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0()); 
            }
            match(input,56,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"
    // InternalEOCL.g:8587: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 {
            // InternalEOCL.g:8591:1: ( rule__LetVariableCS__Group_2__1__Impl )
            // InternalEOCL.g:8592:2: rule__LetVariableCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8598: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 {
            // InternalEOCL.g:8602:1: ( ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalEOCL.g:8603:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalEOCL.g:8603:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            // InternalEOCL.g:8604:2: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1()); 
            }
            // InternalEOCL.g:8605:2: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            // InternalEOCL.g:8605:3: rule__LetVariableCS__OwnedTypeAssignment_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:8614: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 {
            // InternalEOCL.g:8618:1: ( rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 )
            // InternalEOCL.g:8619:2: rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1
            {
            pushFollow(FOLLOW_4);
            rule__NestedExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8626:1: rule__NestedExpCS__Group__0__Impl : ( '(' ) ;
    public final void rule__NestedExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8630:1: ( ( '(' ) )
            // InternalEOCL.g:8631:1: ( '(' )
            {
            // InternalEOCL.g:8631:1: ( '(' )
            // InternalEOCL.g:8632:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0()); 
            }
            match(input,53,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"
    // InternalEOCL.g:8641: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 {
            // InternalEOCL.g:8645:1: ( rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 )
            // InternalEOCL.g:8646:2: rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2
            {
            pushFollow(FOLLOW_8);
            rule__NestedExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8653:1: rule__NestedExpCS__Group__1__Impl : ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) ;
    public final void rule__NestedExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8657:1: ( ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) )
            // InternalEOCL.g:8658:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            {
            // InternalEOCL.g:8658:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            // InternalEOCL.g:8659:2: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1()); 
            }
            // InternalEOCL.g:8660:2: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            // InternalEOCL.g:8660:3: rule__NestedExpCS__OwnedExpressionAssignment_1
            {
            pushFollow(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"
    // InternalEOCL.g:8668:1: rule__NestedExpCS__Group__2 : rule__NestedExpCS__Group__2__Impl ;
    public final void rule__NestedExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8672:1: ( rule__NestedExpCS__Group__2__Impl )
            // InternalEOCL.g:8673:2: rule__NestedExpCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8679:1: rule__NestedExpCS__Group__2__Impl : ( ')' ) ;
    public final void rule__NestedExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8683:1: ( ( ')' ) )
            // InternalEOCL.g:8684:1: ( ')' )
            {
            // InternalEOCL.g:8684:1: ( ')' )
            // InternalEOCL.g:8685:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2()); 
            }
            match(input,54,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"
    // InternalEOCL.g:8695: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 {
            // InternalEOCL.g:8699:1: ( rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 )
            // InternalEOCL.g:8700:2: rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1
            {
            pushFollow(FOLLOW_44);
            rule__SelfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8707:1: rule__SelfExpCS__Group__0__Impl : ( () ) ;
    public final void rule__SelfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8711:1: ( ( () ) )
            // InternalEOCL.g:8712:1: ( () )
            {
            // InternalEOCL.g:8712:1: ( () )
            // InternalEOCL.g:8713:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0()); 
            }
            // InternalEOCL.g:8714:2: ()
            // InternalEOCL.g:8714:3: 
            {
            }

            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"
    // InternalEOCL.g:8722:1: rule__SelfExpCS__Group__1 : rule__SelfExpCS__Group__1__Impl ;
    public final void rule__SelfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8726:1: ( rule__SelfExpCS__Group__1__Impl )
            // InternalEOCL.g:8727:2: rule__SelfExpCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8733:1: rule__SelfExpCS__Group__1__Impl : ( 'self' ) ;
    public final void rule__SelfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8737:1: ( ( 'self' ) )
            // InternalEOCL.g:8738:1: ( 'self' )
            {
            // InternalEOCL.g:8738:1: ( 'self' )
            // InternalEOCL.g:8739:2: 'self'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1()); 
            }
            match(input,75,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"
    // InternalEOCL.g:8749: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 {
            // InternalEOCL.g:8753:1: ( rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 )
            // InternalEOCL.g:8754:2: rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1
            {
            pushFollow(FOLLOW_16);
            rule__MultiplicityBoundsCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8761:1: rule__MultiplicityBoundsCS__Group__0__Impl : ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) ;
    public final void rule__MultiplicityBoundsCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8765:1: ( ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) )
            // InternalEOCL.g:8766:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            {
            // InternalEOCL.g:8766:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            // InternalEOCL.g:8767:2: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0()); 
            }
            // InternalEOCL.g:8768:2: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            // InternalEOCL.g:8768:3: rule__MultiplicityBoundsCS__LowerBoundAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:8776:1: rule__MultiplicityBoundsCS__Group__1 : rule__MultiplicityBoundsCS__Group__1__Impl ;
    public final void rule__MultiplicityBoundsCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8780:1: ( rule__MultiplicityBoundsCS__Group__1__Impl )
            // InternalEOCL.g:8781:2: rule__MultiplicityBoundsCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8787: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 {
            // InternalEOCL.g:8791:1: ( ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) )
            // InternalEOCL.g:8792:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            {
            // InternalEOCL.g:8792:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            // InternalEOCL.g:8793:2: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:8794:2: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==59) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // InternalEOCL.g:8794:3: rule__MultiplicityBoundsCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:8803: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 {
            // InternalEOCL.g:8807:1: ( rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 )
            // InternalEOCL.g:8808:2: rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1
            {
            pushFollow(FOLLOW_45);
            rule__MultiplicityBoundsCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8815:1: rule__MultiplicityBoundsCS__Group_1__0__Impl : ( '..' ) ;
    public final void rule__MultiplicityBoundsCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8819:1: ( ( '..' ) )
            // InternalEOCL.g:8820:1: ( '..' )
            {
            // InternalEOCL.g:8820:1: ( '..' )
            // InternalEOCL.g:8821:2: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0()); 
            }
            match(input,59,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"
    // InternalEOCL.g:8830: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 {
            // InternalEOCL.g:8834:1: ( rule__MultiplicityBoundsCS__Group_1__1__Impl )
            // InternalEOCL.g:8835:2: rule__MultiplicityBoundsCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8841: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 {
            // InternalEOCL.g:8845:1: ( ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) )
            // InternalEOCL.g:8846:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            {
            // InternalEOCL.g:8846:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            // InternalEOCL.g:8847:2: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1()); 
            }
            // InternalEOCL.g:8848:2: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            // InternalEOCL.g:8848:3: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:8857: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 {
            // InternalEOCL.g:8861:1: ( rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 )
            // InternalEOCL.g:8862:2: rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1
            {
            pushFollow(FOLLOW_46);
            rule__MultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8869:1: rule__MultiplicityCS__Group__0__Impl : ( '[' ) ;
    public final void rule__MultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8873:1: ( ( '[' ) )
            // InternalEOCL.g:8874:1: ( '[' )
            {
            // InternalEOCL.g:8874:1: ( '[' )
            // InternalEOCL.g:8875:2: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0()); 
            }
            match(input,66,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"
    // InternalEOCL.g:8884: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 {
            // InternalEOCL.g:8888:1: ( rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 )
            // InternalEOCL.g:8889:2: rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2
            {
            pushFollow(FOLLOW_47);
            rule__MultiplicityCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8896:1: rule__MultiplicityCS__Group__1__Impl : ( ( rule__MultiplicityCS__Alternatives_1 ) ) ;
    public final void rule__MultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8900:1: ( ( ( rule__MultiplicityCS__Alternatives_1 ) ) )
            // InternalEOCL.g:8901:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            {
            // InternalEOCL.g:8901:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            // InternalEOCL.g:8902:2: ( rule__MultiplicityCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1()); 
            }
            // InternalEOCL.g:8903:2: ( rule__MultiplicityCS__Alternatives_1 )
            // InternalEOCL.g:8903:3: rule__MultiplicityCS__Alternatives_1
            {
            pushFollow(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"
    // InternalEOCL.g:8911: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 {
            // InternalEOCL.g:8915:1: ( rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 )
            // InternalEOCL.g:8916:2: rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3
            {
            pushFollow(FOLLOW_47);
            rule__MultiplicityCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8923:1: rule__MultiplicityCS__Group__2__Impl : ( ( rule__MultiplicityCS__Alternatives_2 )? ) ;
    public final void rule__MultiplicityCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8927:1: ( ( ( rule__MultiplicityCS__Alternatives_2 )? ) )
            // InternalEOCL.g:8928:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            {
            // InternalEOCL.g:8928:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            // InternalEOCL.g:8929:2: ( rule__MultiplicityCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_2()); 
            }
            // InternalEOCL.g:8930:2: ( rule__MultiplicityCS__Alternatives_2 )?
            int alt77=2;
            int LA77_0 = input.LA(1);

            if ( (LA77_0==50||LA77_0==84) ) {
                alt77=1;
            }
            switch (alt77) {
                case 1 :
                    // InternalEOCL.g:8930:3: rule__MultiplicityCS__Alternatives_2
                    {
                    pushFollow(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"
    // InternalEOCL.g:8938:1: rule__MultiplicityCS__Group__3 : rule__MultiplicityCS__Group__3__Impl ;
    public final void rule__MultiplicityCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8942:1: ( rule__MultiplicityCS__Group__3__Impl )
            // InternalEOCL.g:8943:2: rule__MultiplicityCS__Group__3__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:8949:1: rule__MultiplicityCS__Group__3__Impl : ( ']' ) ;
    public final void rule__MultiplicityCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8953:1: ( ( ']' ) )
            // InternalEOCL.g:8954:1: ( ']' )
            {
            // InternalEOCL.g:8954:1: ( ']' )
            // InternalEOCL.g:8955:2: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3()); 
            }
            match(input,67,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"
    // InternalEOCL.g:8965: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 {
            // InternalEOCL.g:8969:1: ( rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 )
            // InternalEOCL.g:8970:2: rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1
            {
            pushFollow(FOLLOW_48);
            rule__PathNameCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:8977:1: rule__PathNameCS__Group__0__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) ;
    public final void rule__PathNameCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8981:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) )
            // InternalEOCL.g:8982:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            {
            // InternalEOCL.g:8982:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            // InternalEOCL.g:8983:2: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0()); 
            }
            // InternalEOCL.g:8984:2: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            // InternalEOCL.g:8984:3: rule__PathNameCS__OwnedPathElementsAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:8992:1: rule__PathNameCS__Group__1 : rule__PathNameCS__Group__1__Impl ;
    public final void rule__PathNameCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:8996:1: ( rule__PathNameCS__Group__1__Impl )
            // InternalEOCL.g:8997:2: rule__PathNameCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9003: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 {
            // InternalEOCL.g:9007:1: ( ( ( rule__PathNameCS__Group_1__0 )* ) )
            // InternalEOCL.g:9008:1: ( ( rule__PathNameCS__Group_1__0 )* )
            {
            // InternalEOCL.g:9008:1: ( ( rule__PathNameCS__Group_1__0 )* )
            // InternalEOCL.g:9009:2: ( rule__PathNameCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:9010:2: ( rule__PathNameCS__Group_1__0 )*
            loop78:
            do {
                int alt78=2;
                int LA78_0 = input.LA(1);

                if ( (LA78_0==76) ) {
                    alt78=1;
                }


                switch (alt78) {
            	case 1 :
            	    // InternalEOCL.g:9010:3: rule__PathNameCS__Group_1__0
            	    {
            	    pushFollow(FOLLOW_49);
            	    rule__PathNameCS__Group_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop78;
                }
            } 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"
    // InternalEOCL.g:9019: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 {
            // InternalEOCL.g:9023:1: ( rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 )
            // InternalEOCL.g:9024:2: rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__PathNameCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9031:1: rule__PathNameCS__Group_1__0__Impl : ( '::' ) ;
    public final void rule__PathNameCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9035:1: ( ( '::' ) )
            // InternalEOCL.g:9036:1: ( '::' )
            {
            // InternalEOCL.g:9036:1: ( '::' )
            // InternalEOCL.g:9037:2: '::'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0()); 
            }
            match(input,76,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"
    // InternalEOCL.g:9046: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 {
            // InternalEOCL.g:9050:1: ( rule__PathNameCS__Group_1__1__Impl )
            // InternalEOCL.g:9051:2: rule__PathNameCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9057: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 {
            // InternalEOCL.g:9061:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) )
            // InternalEOCL.g:9062:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            {
            // InternalEOCL.g:9062:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            // InternalEOCL.g:9063:2: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1()); 
            }
            // InternalEOCL.g:9064:2: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            // InternalEOCL.g:9064:3: rule__PathNameCS__OwnedPathElementsAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:9073: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 {
            // InternalEOCL.g:9077:1: ( rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 )
            // InternalEOCL.g:9078:2: rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1
            {
            pushFollow(FOLLOW_50);
            rule__TemplateBindingCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9085:1: rule__TemplateBindingCS__Group__0__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) ;
    public final void rule__TemplateBindingCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9089:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) )
            // InternalEOCL.g:9090:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            {
            // InternalEOCL.g:9090:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            // InternalEOCL.g:9091:2: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0()); 
            }
            // InternalEOCL.g:9092:2: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            // InternalEOCL.g:9092:3: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:9100: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 {
            // InternalEOCL.g:9104:1: ( rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 )
            // InternalEOCL.g:9105:2: rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2
            {
            pushFollow(FOLLOW_50);
            rule__TemplateBindingCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9112: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 {
            // InternalEOCL.g:9116:1: ( ( ( rule__TemplateBindingCS__Group_1__0 )* ) )
            // InternalEOCL.g:9117:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            {
            // InternalEOCL.g:9117:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            // InternalEOCL.g:9118:2: ( rule__TemplateBindingCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:9119:2: ( rule__TemplateBindingCS__Group_1__0 )*
            loop79:
            do {
                int alt79=2;
                int LA79_0 = input.LA(1);

                if ( (LA79_0==55) ) {
                    alt79=1;
                }


                switch (alt79) {
            	case 1 :
            	    // InternalEOCL.g:9119:3: rule__TemplateBindingCS__Group_1__0
            	    {
            	    pushFollow(FOLLOW_11);
            	    rule__TemplateBindingCS__Group_1__0();

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

            	    }
            	    break;

            	default :
            	    break loop79;
                }
            } 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"
    // InternalEOCL.g:9127:1: rule__TemplateBindingCS__Group__2 : rule__TemplateBindingCS__Group__2__Impl ;
    public final void rule__TemplateBindingCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9131:1: ( rule__TemplateBindingCS__Group__2__Impl )
            // InternalEOCL.g:9132:2: rule__TemplateBindingCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9138:1: rule__TemplateBindingCS__Group__2__Impl : ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) ;
    public final void rule__TemplateBindingCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9142:1: ( ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) )
            // InternalEOCL.g:9143:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            {
            // InternalEOCL.g:9143:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            // InternalEOCL.g:9144:2: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2()); 
            }
            // InternalEOCL.g:9145:2: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            int alt80=2;
            int LA80_0 = input.LA(1);

            if ( (LA80_0==66) ) {
                alt80=1;
            }
            switch (alt80) {
                case 1 :
                    // InternalEOCL.g:9145:3: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2
                    {
                    pushFollow(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"
    // InternalEOCL.g:9154: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 {
            // InternalEOCL.g:9158:1: ( rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 )
            // InternalEOCL.g:9159:2: rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1
            {
            pushFollow(FOLLOW_51);
            rule__TemplateBindingCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9166:1: rule__TemplateBindingCS__Group_1__0__Impl : ( ',' ) ;
    public final void rule__TemplateBindingCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9170:1: ( ( ',' ) )
            // InternalEOCL.g:9171:1: ( ',' )
            {
            // InternalEOCL.g:9171:1: ( ',' )
            // InternalEOCL.g:9172:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:9181: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 {
            // InternalEOCL.g:9185:1: ( rule__TemplateBindingCS__Group_1__1__Impl )
            // InternalEOCL.g:9186:2: rule__TemplateBindingCS__Group_1__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9192: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 {
            // InternalEOCL.g:9196:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) )
            // InternalEOCL.g:9197:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            {
            // InternalEOCL.g:9197:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            // InternalEOCL.g:9198:2: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1()); 
            }
            // InternalEOCL.g:9199:2: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            // InternalEOCL.g:9199:3: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:9208: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 {
            // InternalEOCL.g:9212:1: ( rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 )
            // InternalEOCL.g:9213:2: rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1
            {
            pushFollow(FOLLOW_52);
            rule__TypeParameterCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9220:1: rule__TypeParameterCS__Group__0__Impl : ( ( rule__TypeParameterCS__NameAssignment_0 ) ) ;
    public final void rule__TypeParameterCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9224:1: ( ( ( rule__TypeParameterCS__NameAssignment_0 ) ) )
            // InternalEOCL.g:9225:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            {
            // InternalEOCL.g:9225:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            // InternalEOCL.g:9226:2: ( rule__TypeParameterCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0()); 
            }
            // InternalEOCL.g:9227:2: ( rule__TypeParameterCS__NameAssignment_0 )
            // InternalEOCL.g:9227:3: rule__TypeParameterCS__NameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:9235:1: rule__TypeParameterCS__Group__1 : rule__TypeParameterCS__Group__1__Impl ;
    public final void rule__TypeParameterCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9239:1: ( rule__TypeParameterCS__Group__1__Impl )
            // InternalEOCL.g:9240:2: rule__TypeParameterCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9246: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 {
            // InternalEOCL.g:9250:1: ( ( ( rule__TypeParameterCS__Group_1__0 )? ) )
            // InternalEOCL.g:9251:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            {
            // InternalEOCL.g:9251:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            // InternalEOCL.g:9252:2: ( rule__TypeParameterCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:9253:2: ( rule__TypeParameterCS__Group_1__0 )?
            int alt81=2;
            int LA81_0 = input.LA(1);

            if ( (LA81_0==77) ) {
                alt81=1;
            }
            switch (alt81) {
                case 1 :
                    // InternalEOCL.g:9253:3: rule__TypeParameterCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:9262: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 {
            // InternalEOCL.g:9266:1: ( rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 )
            // InternalEOCL.g:9267:2: rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1
            {
            pushFollow(FOLLOW_7);
            rule__TypeParameterCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9274:1: rule__TypeParameterCS__Group_1__0__Impl : ( 'extends' ) ;
    public final void rule__TypeParameterCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9278:1: ( ( 'extends' ) )
            // InternalEOCL.g:9279:1: ( 'extends' )
            {
            // InternalEOCL.g:9279:1: ( 'extends' )
            // InternalEOCL.g:9280:2: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0()); 
            }
            match(input,77,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"
    // InternalEOCL.g:9289: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 {
            // InternalEOCL.g:9293:1: ( rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 )
            // InternalEOCL.g:9294:2: rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2
            {
            pushFollow(FOLLOW_53);
            rule__TypeParameterCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9301: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 {
            // InternalEOCL.g:9305:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) )
            // InternalEOCL.g:9306:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            {
            // InternalEOCL.g:9306:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            // InternalEOCL.g:9307:2: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1()); 
            }
            // InternalEOCL.g:9308:2: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            // InternalEOCL.g:9308:3: rule__TypeParameterCS__OwnedExtendsAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:9316: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 {
            // InternalEOCL.g:9320:1: ( rule__TypeParameterCS__Group_1__2__Impl )
            // InternalEOCL.g:9321:2: rule__TypeParameterCS__Group_1__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9327: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 {
            // InternalEOCL.g:9331:1: ( ( ( rule__TypeParameterCS__Group_1_2__0 )* ) )
            // InternalEOCL.g:9332:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            {
            // InternalEOCL.g:9332:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            // InternalEOCL.g:9333:2: ( rule__TypeParameterCS__Group_1_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1_2()); 
            }
            // InternalEOCL.g:9334:2: ( rule__TypeParameterCS__Group_1_2__0 )*
            loop82:
            do {
                int alt82=2;
                int LA82_0 = input.LA(1);

                if ( (LA82_0==78) ) {
                    alt82=1;
                }


                switch (alt82) {
            	case 1 :
            	    // InternalEOCL.g:9334:3: rule__TypeParameterCS__Group_1_2__0
            	    {
            	    pushFollow(FOLLOW_54);
            	    rule__TypeParameterCS__Group_1_2__0();

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

            	    }
            	    break;

            	default :
            	    break loop82;
                }
            } 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"
    // InternalEOCL.g:9343: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 {
            // InternalEOCL.g:9347:1: ( rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 )
            // InternalEOCL.g:9348:2: rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1
            {
            pushFollow(FOLLOW_7);
            rule__TypeParameterCS__Group_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9355:1: rule__TypeParameterCS__Group_1_2__0__Impl : ( '&&' ) ;
    public final void rule__TypeParameterCS__Group_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9359:1: ( ( '&&' ) )
            // InternalEOCL.g:9360:1: ( '&&' )
            {
            // InternalEOCL.g:9360:1: ( '&&' )
            // InternalEOCL.g:9361:2: '&&'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0()); 
            }
            match(input,78,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"
    // InternalEOCL.g:9370: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 {
            // InternalEOCL.g:9374:1: ( rule__TypeParameterCS__Group_1_2__1__Impl )
            // InternalEOCL.g:9375:2: rule__TypeParameterCS__Group_1_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9381: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 {
            // InternalEOCL.g:9385:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) )
            // InternalEOCL.g:9386:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            {
            // InternalEOCL.g:9386:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            // InternalEOCL.g:9387:2: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1()); 
            }
            // InternalEOCL.g:9388:2: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            // InternalEOCL.g:9388:3: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1
            {
            pushFollow(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"
    // InternalEOCL.g:9397: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 {
            // InternalEOCL.g:9401:1: ( rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 )
            // InternalEOCL.g:9402:2: rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__TypedTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9409:1: rule__TypedTypeRefCS__Group__0__Impl : ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypedTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9413:1: ( ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) )
            // InternalEOCL.g:9414:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalEOCL.g:9414:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            // InternalEOCL.g:9415:2: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0()); 
            }
            // InternalEOCL.g:9416:2: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            // InternalEOCL.g:9416:3: rule__TypedTypeRefCS__OwnedPathNameAssignment_0
            {
            pushFollow(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"
    // InternalEOCL.g:9424:1: rule__TypedTypeRefCS__Group__1 : rule__TypedTypeRefCS__Group__1__Impl ;
    public final void rule__TypedTypeRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9428:1: ( rule__TypedTypeRefCS__Group__1__Impl )
            // InternalEOCL.g:9429:2: rule__TypedTypeRefCS__Group__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9435: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 {
            // InternalEOCL.g:9439:1: ( ( ( rule__TypedTypeRefCS__Group_1__0 )? ) )
            // InternalEOCL.g:9440:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            {
            // InternalEOCL.g:9440:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            // InternalEOCL.g:9441:2: ( rule__TypedTypeRefCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup_1()); 
            }
            // InternalEOCL.g:9442:2: ( rule__TypedTypeRefCS__Group_1__0 )?
            int alt83=2;
            int LA83_0 = input.LA(1);

            if ( (LA83_0==53) ) {
                alt83=1;
            }
            switch (alt83) {
                case 1 :
                    // InternalEOCL.g:9442:3: rule__TypedTypeRefCS__Group_1__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:9451: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 {
            // InternalEOCL.g:9455:1: ( rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 )
            // InternalEOCL.g:9456:2: rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1
            {
            pushFollow(FOLLOW_51);
            rule__TypedTypeRefCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9463:1: rule__TypedTypeRefCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TypedTypeRefCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9467:1: ( ( '(' ) )
            // InternalEOCL.g:9468:1: ( '(' )
            {
            // InternalEOCL.g:9468:1: ( '(' )
            // InternalEOCL.g:9469:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0()); 
            }
            match(input,53,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"
    // InternalEOCL.g:9478: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 {
            // InternalEOCL.g:9482:1: ( rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 )
            // InternalEOCL.g:9483:2: rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2
            {
            pushFollow(FOLLOW_8);
            rule__TypedTypeRefCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9490: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 {
            // InternalEOCL.g:9494:1: ( ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) )
            // InternalEOCL.g:9495:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            {
            // InternalEOCL.g:9495:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            // InternalEOCL.g:9496:2: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1()); 
            }
            // InternalEOCL.g:9497:2: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            // InternalEOCL.g:9497:3: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1
            {
            pushFollow(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"
    // InternalEOCL.g:9505: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 {
            // InternalEOCL.g:9509:1: ( rule__TypedTypeRefCS__Group_1__2__Impl )
            // InternalEOCL.g:9510:2: rule__TypedTypeRefCS__Group_1__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9516:1: rule__TypedTypeRefCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TypedTypeRefCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9520:1: ( ( ')' ) )
            // InternalEOCL.g:9521:1: ( ')' )
            {
            // InternalEOCL.g:9521:1: ( ')' )
            // InternalEOCL.g:9522:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2()); 
            }
            match(input,54,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"
    // InternalEOCL.g:9532: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 {
            // InternalEOCL.g:9536:1: ( rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 )
            // InternalEOCL.g:9537:2: rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1
            {
            pushFollow(FOLLOW_51);
            rule__WildcardTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9544:1: rule__WildcardTypeRefCS__Group__0__Impl : ( () ) ;
    public final void rule__WildcardTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9548:1: ( ( () ) )
            // InternalEOCL.g:9549:1: ( () )
            {
            // InternalEOCL.g:9549:1: ( () )
            // InternalEOCL.g:9550:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0()); 
            }
            // InternalEOCL.g:9551:2: ()
            // InternalEOCL.g:9551:3: 
            {
            }

            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"
    // InternalEOCL.g:9559: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 {
            // InternalEOCL.g:9563:1: ( rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 )
            // InternalEOCL.g:9564:2: rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2
            {
            pushFollow(FOLLOW_52);
            rule__WildcardTypeRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9571:1: rule__WildcardTypeRefCS__Group__1__Impl : ( '?' ) ;
    public final void rule__WildcardTypeRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9575:1: ( ( '?' ) )
            // InternalEOCL.g:9576:1: ( '?' )
            {
            // InternalEOCL.g:9576:1: ( '?' )
            // InternalEOCL.g:9577:2: '?'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1()); 
            }
            match(input,51,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"
    // InternalEOCL.g:9586:1: rule__WildcardTypeRefCS__Group__2 : rule__WildcardTypeRefCS__Group__2__Impl ;
    public final void rule__WildcardTypeRefCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9590:1: ( rule__WildcardTypeRefCS__Group__2__Impl )
            // InternalEOCL.g:9591:2: rule__WildcardTypeRefCS__Group__2__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9597: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 {
            // InternalEOCL.g:9601:1: ( ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) )
            // InternalEOCL.g:9602:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            {
            // InternalEOCL.g:9602:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            // InternalEOCL.g:9603:2: ( rule__WildcardTypeRefCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2()); 
            }
            // InternalEOCL.g:9604:2: ( rule__WildcardTypeRefCS__Group_2__0 )?
            int alt84=2;
            int LA84_0 = input.LA(1);

            if ( (LA84_0==77) ) {
                alt84=1;
            }
            switch (alt84) {
                case 1 :
                    // InternalEOCL.g:9604:3: rule__WildcardTypeRefCS__Group_2__0
                    {
                    pushFollow(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"
    // InternalEOCL.g:9613: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 {
            // InternalEOCL.g:9617:1: ( rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 )
            // InternalEOCL.g:9618:2: rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1
            {
            pushFollow(FOLLOW_7);
            rule__WildcardTypeRefCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(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"
    // InternalEOCL.g:9625:1: rule__WildcardTypeRefCS__Group_2__0__Impl : ( 'extends' ) ;
    public final void rule__WildcardTypeRefCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9629:1: ( ( 'extends' ) )
            // InternalEOCL.g:9630:1: ( 'extends' )
            {
            // InternalEOCL.g:9630:1: ( 'extends' )
            // InternalEOCL.g:9631:2: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0()); 
            }
            match(input,77,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"
    // InternalEOCL.g:9640: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 {
            // InternalEOCL.g:9644:1: ( rule__WildcardTypeRefCS__Group_2__1__Impl )
            // InternalEOCL.g:9645:2: rule__WildcardTypeRefCS__Group_2__1__Impl
            {
            pushFollow(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"
    // InternalEOCL.g:9651: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 {
            // InternalEOCL.g:9655:1: ( ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) )
            // InternalEOCL.g:9656:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            {
            // InternalEOCL.g:9656:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            // InternalEOCL.g:9657:2: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1()); 
            }
            // InternalEOCL.g:9658:2: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            // InternalEOCL.g:9658:3: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1
            {
            pushFollow(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__Greeting__ModelAssignment_1"
    // InternalEOCL.g:9667:1: rule__Greeting__ModelAssignment_1 : ( ruleModel ) ;
    public final void rule__Greeting__ModelAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9671:1: ( ( ruleModel ) )
            // InternalEOCL.g:9672:2: ( ruleModel )
            {
            // InternalEOCL.g:9672:2: ( ruleModel )
            // InternalEOCL.g:9673:3: ruleModel
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getGreetingAccess().getModelModelParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleModel();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__Model__OwnedExpressionAssignment"
    // InternalEOCL.g:9682:1: rule__Model__OwnedExpressionAssignment : ( ruleExpCS ) ;
    public final void rule__Model__OwnedExpressionAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9686:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:9687:2: ( ruleExpCS )
            {
            // InternalEOCL.g:9687:2: ( ruleExpCS )
            // InternalEOCL.g:9688:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getModelAccess().getOwnedExpressionExpCSParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9697:1: rule__URIFirstPathElementCS__ReferredElementAssignment_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9701:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEOCL.g:9702:2: ( ( ruleUnrestrictedName ) )
            {
            // InternalEOCL.g:9702:2: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:9703:3: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0()); 
            }
            // InternalEOCL.g:9704:3: ( ruleUnrestrictedName )
            // InternalEOCL.g:9705:4: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9716:1: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 : ( ( ruleURI ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9720:1: ( ( ( ruleURI ) ) )
            // InternalEOCL.g:9721:2: ( ( ruleURI ) )
            {
            // InternalEOCL.g:9721:2: ( ( ruleURI ) )
            // InternalEOCL.g:9722:3: ( ruleURI )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0()); 
            }
            // InternalEOCL.g:9723:3: ( ruleURI )
            // InternalEOCL.g:9724:4: ruleURI
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9735:1: rule__PrimitiveTypeCS__NameAssignment : ( rulePrimitiveTypeIdentifier ) ;
    public final void rule__PrimitiveTypeCS__NameAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9739:1: ( ( rulePrimitiveTypeIdentifier ) )
            // InternalEOCL.g:9740:2: ( rulePrimitiveTypeIdentifier )
            {
            // InternalEOCL.g:9740:2: ( rulePrimitiveTypeIdentifier )
            // InternalEOCL.g:9741:3: rulePrimitiveTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9750:1: rule__CollectionTypeCS__NameAssignment_0 : ( ruleCollectionTypeIdentifier ) ;
    public final void rule__CollectionTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9754:1: ( ( ruleCollectionTypeIdentifier ) )
            // InternalEOCL.g:9755:2: ( ruleCollectionTypeIdentifier )
            {
            // InternalEOCL.g:9755:2: ( ruleCollectionTypeIdentifier )
            // InternalEOCL.g:9756:3: ruleCollectionTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9765:1: rule__CollectionTypeCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__CollectionTypeCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9769:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:9770:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:9770:2: ( ruleTypeExpCS )
            // InternalEOCL.g:9771:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpCSParserRuleCall_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__MapTypeCS__NameAssignment_0"
    // InternalEOCL.g:9780:1: rule__MapTypeCS__NameAssignment_0 : ( ( 'Map' ) ) ;
    public final void rule__MapTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9784:1: ( ( ( 'Map' ) ) )
            // InternalEOCL.g:9785:2: ( ( 'Map' ) )
            {
            // InternalEOCL.g:9785:2: ( ( 'Map' ) )
            // InternalEOCL.g:9786:3: ( 'Map' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); 
            }
            // InternalEOCL.g:9787:3: ( 'Map' )
            // InternalEOCL.g:9788:4: 'Map'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0()); 
            }
            match(input,35,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"
    // InternalEOCL.g:9799:1: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedKeyTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9803:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:9804:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:9804:2: ( ruleTypeExpCS )
            // InternalEOCL.g:9805:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9814:1: rule__MapTypeCS__OwnedValueTypeAssignment_1_3 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedValueTypeAssignment_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9818:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:9819:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:9819:2: ( ruleTypeExpCS )
            // InternalEOCL.g:9820:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9829:1: rule__TupleTypeCS__NameAssignment_0 : ( ( 'Tuple' ) ) ;
    public final void rule__TupleTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9833:1: ( ( ( 'Tuple' ) ) )
            // InternalEOCL.g:9834:2: ( ( 'Tuple' ) )
            {
            // InternalEOCL.g:9834:2: ( ( 'Tuple' ) )
            // InternalEOCL.g:9835:3: ( 'Tuple' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); 
            }
            // InternalEOCL.g:9836:3: ( 'Tuple' )
            // InternalEOCL.g:9837:4: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0()); 
            }
            match(input,36,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"
    // InternalEOCL.g:9848:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 : ( ruleTuplePartCS ) ;
    public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9852:1: ( ( ruleTuplePartCS ) )
            // InternalEOCL.g:9853:2: ( ruleTuplePartCS )
            {
            // InternalEOCL.g:9853:2: ( ruleTuplePartCS )
            // InternalEOCL.g:9854:3: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9863: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 {
            // InternalEOCL.g:9867:1: ( ( ruleTuplePartCS ) )
            // InternalEOCL.g:9868:2: ( ruleTuplePartCS )
            {
            // InternalEOCL.g:9868:2: ( ruleTuplePartCS )
            // InternalEOCL.g:9869:3: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9878:1: rule__TuplePartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TuplePartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9882:1: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:9883:2: ( ruleUnrestrictedName )
            {
            // InternalEOCL.g:9883:2: ( ruleUnrestrictedName )
            // InternalEOCL.g:9884:3: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9893:1: rule__TuplePartCS__OwnedTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__TuplePartCS__OwnedTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9897:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:9898:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:9898:2: ( ruleTypeExpCS )
            // InternalEOCL.g:9899:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9908:1: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9912:1: ( ( ruleCollectionTypeCS ) )
            // InternalEOCL.g:9913:2: ( ruleCollectionTypeCS )
            {
            // InternalEOCL.g:9913:2: ( ruleCollectionTypeCS )
            // InternalEOCL.g:9914:3: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9923:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9927:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalEOCL.g:9928:2: ( ruleCollectionLiteralPartCS )
            {
            // InternalEOCL.g:9928:2: ( ruleCollectionLiteralPartCS )
            // InternalEOCL.g:9929:3: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9938:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9942:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalEOCL.g:9943:2: ( ruleCollectionLiteralPartCS )
            {
            // InternalEOCL.g:9943:2: ( ruleCollectionLiteralPartCS )
            // InternalEOCL.g:9944:3: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9953:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9957:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:9958:2: ( ruleExpCS )
            {
            // InternalEOCL.g:9958:2: ( ruleExpCS )
            // InternalEOCL.g:9959:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9968:1: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9972:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:9973:2: ( ruleExpCS )
            {
            // InternalEOCL.g:9973:2: ( ruleExpCS )
            // InternalEOCL.g:9974:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9983:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:9987:1: ( ( rulePatternExpCS ) )
            // InternalEOCL.g:9988:2: ( rulePatternExpCS )
            {
            // InternalEOCL.g:9988:2: ( rulePatternExpCS )
            // InternalEOCL.g:9989:3: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:9998:1: rule__CollectionPatternCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionPatternCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10002:1: ( ( ruleCollectionTypeCS ) )
            // InternalEOCL.g:10003:2: ( ruleCollectionTypeCS )
            {
            // InternalEOCL.g:10003:2: ( ruleCollectionTypeCS )
            // InternalEOCL.g:10004:3: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10013:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_0 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10017:1: ( ( rulePatternExpCS ) )
            // InternalEOCL.g:10018:2: ( rulePatternExpCS )
            {
            // InternalEOCL.g:10018:2: ( rulePatternExpCS )
            // InternalEOCL.g:10019:3: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10028:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10032:1: ( ( rulePatternExpCS ) )
            // InternalEOCL.g:10033:2: ( rulePatternExpCS )
            {
            // InternalEOCL.g:10033:2: ( rulePatternExpCS )
            // InternalEOCL.g:10034:3: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10043:1: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 : ( ruleIdentifier ) ;
    public final void rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10047:1: ( ( ruleIdentifier ) )
            // InternalEOCL.g:10048:2: ( ruleIdentifier )
            {
            // InternalEOCL.g:10048:2: ( ruleIdentifier )
            // InternalEOCL.g:10049:3: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10058:1: rule__ShadowPartCS__ReferredPropertyAssignment_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__ShadowPartCS__ReferredPropertyAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10062:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEOCL.g:10063:2: ( ( ruleUnrestrictedName ) )
            {
            // InternalEOCL.g:10063:2: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:10064:3: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0()); 
            }
            // InternalEOCL.g:10065:3: ( ruleUnrestrictedName )
            // InternalEOCL.g:10066:4: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_1()); 
            }
            pushFollow(FOLLOW_2);
            ruleUnrestrictedName();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_2"
    // InternalEOCL.g:10077:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_2 : ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 ) ) ;
    public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10081:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 ) ) )
            // InternalEOCL.g:10082:2: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 ) )
            {
            // InternalEOCL.g:10082:2: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 ) )
            // InternalEOCL.g:10083:3: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_2_0()); 
            }
            // InternalEOCL.g:10084:3: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0 )
            // InternalEOCL.g:10084:4: rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0
            {
            pushFollow(FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAlternatives_2_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PatternExpCS__PatternVariableNameAssignment_0"
    // InternalEOCL.g:10092:1: rule__PatternExpCS__PatternVariableNameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__PatternExpCS__PatternVariableNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10096:1: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:10097:2: ( ruleUnrestrictedName )
            {
            // InternalEOCL.g:10097:2: ( ruleUnrestrictedName )
            // InternalEOCL.g:10098:3: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10107:1: rule__PatternExpCS__OwnedPatternTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__PatternExpCS__OwnedPatternTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10111:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10112:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10112:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10113:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10122:1: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 : ( ruleExpCS ) ;
    public final void rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10126:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10127:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10127:2: ( ruleExpCS )
            // InternalEOCL.g:10128:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10137:1: rule__MapLiteralExpCS__OwnedTypeAssignment_0 : ( ruleMapTypeCS ) ;
    public final void rule__MapLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10141:1: ( ( ruleMapTypeCS ) )
            // InternalEOCL.g:10142:2: ( ruleMapTypeCS )
            {
            // InternalEOCL.g:10142:2: ( ruleMapTypeCS )
            // InternalEOCL.g:10143:3: ruleMapTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10152:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10156:1: ( ( ruleMapLiteralPartCS ) )
            // InternalEOCL.g:10157:2: ( ruleMapLiteralPartCS )
            {
            // InternalEOCL.g:10157:2: ( ruleMapLiteralPartCS )
            // InternalEOCL.g:10158:3: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10167:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10171:1: ( ( ruleMapLiteralPartCS ) )
            // InternalEOCL.g:10172:2: ( ruleMapLiteralPartCS )
            {
            // InternalEOCL.g:10172:2: ( ruleMapLiteralPartCS )
            // InternalEOCL.g:10173:3: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10182:1: rule__MapLiteralPartCS__OwnedKeyAssignment_0 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedKeyAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10186:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10187:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10187:2: ( ruleExpCS )
            // InternalEOCL.g:10188:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10197:1: rule__MapLiteralPartCS__OwnedValueAssignment_2 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedValueAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10201:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10202:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10202:2: ( ruleExpCS )
            // InternalEOCL.g:10203:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10212:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_2 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10216:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalEOCL.g:10217:2: ( ruleTupleLiteralPartCS )
            {
            // InternalEOCL.g:10217:2: ( ruleTupleLiteralPartCS )
            // InternalEOCL.g:10218:3: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10227:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10231:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalEOCL.g:10232:2: ( ruleTupleLiteralPartCS )
            {
            // InternalEOCL.g:10232:2: ( ruleTupleLiteralPartCS )
            // InternalEOCL.g:10233:3: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10242:1: rule__TupleLiteralPartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TupleLiteralPartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10246:1: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:10247:2: ( ruleUnrestrictedName )
            {
            // InternalEOCL.g:10247:2: ( ruleUnrestrictedName )
            // InternalEOCL.g:10248:3: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10257:1: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10261:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10262:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10262:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10263:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10272:1: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10276:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10277:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10277:2: ( ruleExpCS )
            // InternalEOCL.g:10278:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10287:1: rule__NumberLiteralExpCS__SymbolAssignment : ( ruleNUMBER_LITERAL ) ;
    public final void rule__NumberLiteralExpCS__SymbolAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10291:1: ( ( ruleNUMBER_LITERAL ) )
            // InternalEOCL.g:10292:2: ( ruleNUMBER_LITERAL )
            {
            // InternalEOCL.g:10292:2: ( ruleNUMBER_LITERAL )
            // InternalEOCL.g:10293:3: ruleNUMBER_LITERAL
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10302:1: rule__StringLiteralExpCS__SegmentsAssignment : ( ruleStringLiteral ) ;
    public final void rule__StringLiteralExpCS__SegmentsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10306:1: ( ( ruleStringLiteral ) )
            // InternalEOCL.g:10307:2: ( ruleStringLiteral )
            {
            // InternalEOCL.g:10307:2: ( ruleStringLiteral )
            // InternalEOCL.g:10308:3: ruleStringLiteral
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10317:1: rule__BooleanLiteralExpCS__SymbolAssignment_0 : ( ( 'true' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10321:1: ( ( ( 'true' ) ) )
            // InternalEOCL.g:10322:2: ( ( 'true' ) )
            {
            // InternalEOCL.g:10322:2: ( ( 'true' ) )
            // InternalEOCL.g:10323:3: ( 'true' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); 
            }
            // InternalEOCL.g:10324:3: ( 'true' )
            // InternalEOCL.g:10325:4: 'true'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0()); 
            }
            match(input,79,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"
    // InternalEOCL.g:10336:1: rule__BooleanLiteralExpCS__SymbolAssignment_1 : ( ( 'false' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10340:1: ( ( ( 'false' ) ) )
            // InternalEOCL.g:10341:2: ( ( 'false' ) )
            {
            // InternalEOCL.g:10341:2: ( ( 'false' ) )
            // InternalEOCL.g:10342:3: ( 'false' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); 
            }
            // InternalEOCL.g:10343:3: ( 'false' )
            // InternalEOCL.g:10344:4: 'false'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0()); 
            }
            match(input,80,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"
    // InternalEOCL.g:10355:1: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10359:1: ( ( ruleMultiplicityCS ) )
            // InternalEOCL.g:10360:2: ( ruleMultiplicityCS )
            {
            // InternalEOCL.g:10360:2: ( ruleMultiplicityCS )
            // InternalEOCL.g:10361:3: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10370:1: rule__TypeLiteralExpCS__OwnedTypeAssignment : ( ruleTypeLiteralWithMultiplicityCS ) ;
    public final void rule__TypeLiteralExpCS__OwnedTypeAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10374:1: ( ( ruleTypeLiteralWithMultiplicityCS ) )
            // InternalEOCL.g:10375:2: ( ruleTypeLiteralWithMultiplicityCS )
            {
            // InternalEOCL.g:10375:2: ( ruleTypeLiteralWithMultiplicityCS )
            // InternalEOCL.g:10376:3: ruleTypeLiteralWithMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10385:1: rule__TypeNameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypeNameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10389:1: ( ( rulePathNameCS ) )
            // InternalEOCL.g:10390:2: ( rulePathNameCS )
            {
            // InternalEOCL.g:10390:2: ( rulePathNameCS )
            // InternalEOCL.g:10391:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10400:1: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10404:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalEOCL.g:10405:2: ( ruleCurlyBracketedClauseCS )
            {
            // InternalEOCL.g:10405:2: ( ruleCurlyBracketedClauseCS )
            // InternalEOCL.g:10406:3: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10415:1: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 : ( ruleExpCS ) ;
    public final void rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10419:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10420:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10420:2: ( ruleExpCS )
            // InternalEOCL.g:10421:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10430:1: rule__TypeExpCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeExpCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10434:1: ( ( ruleMultiplicityCS ) )
            // InternalEOCL.g:10435:2: ( ruleMultiplicityCS )
            {
            // InternalEOCL.g:10435:2: ( ruleMultiplicityCS )
            // InternalEOCL.g:10436:3: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10445:1: rule__ExpCS__NameAssignment_0_1_1 : ( ruleBinaryOperatorName ) ;
    public final void rule__ExpCS__NameAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10449:1: ( ( ruleBinaryOperatorName ) )
            // InternalEOCL.g:10450:2: ( ruleBinaryOperatorName )
            {
            // InternalEOCL.g:10450:2: ( ruleBinaryOperatorName )
            // InternalEOCL.g:10451:3: ruleBinaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10460:1: rule__ExpCS__OwnedRightAssignment_0_1_2 : ( ruleExpCS ) ;
    public final void rule__ExpCS__OwnedRightAssignment_0_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10464:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10465:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10465:2: ( ruleExpCS )
            // InternalEOCL.g:10466:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10475:1: rule__PrefixedLetExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedLetExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10479:1: ( ( ruleUnaryOperatorName ) )
            // InternalEOCL.g:10480:2: ( ruleUnaryOperatorName )
            {
            // InternalEOCL.g:10480:2: ( ruleUnaryOperatorName )
            // InternalEOCL.g:10481:3: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10490:1: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedLetExpCS ) ;
    public final void rule__PrefixedLetExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10494:1: ( ( rulePrefixedLetExpCS ) )
            // InternalEOCL.g:10495:2: ( rulePrefixedLetExpCS )
            {
            // InternalEOCL.g:10495:2: ( rulePrefixedLetExpCS )
            // InternalEOCL.g:10496:3: rulePrefixedLetExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10505:1: rule__PrefixedPrimaryExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedPrimaryExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10509:1: ( ( ruleUnaryOperatorName ) )
            // InternalEOCL.g:10510:2: ( ruleUnaryOperatorName )
            {
            // InternalEOCL.g:10510:2: ( ruleUnaryOperatorName )
            // InternalEOCL.g:10511:3: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10520:1: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10524:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalEOCL.g:10525:2: ( rulePrefixedPrimaryExpCS )
            {
            // InternalEOCL.g:10525:2: ( rulePrefixedPrimaryExpCS )
            // InternalEOCL.g:10526:3: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10535:1: rule__NameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__NameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10539:1: ( ( rulePathNameCS ) )
            // InternalEOCL.g:10540:2: ( rulePathNameCS )
            {
            // InternalEOCL.g:10540:2: ( rulePathNameCS )
            // InternalEOCL.g:10541:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10550:1: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 : ( ruleSquareBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10554:1: ( ( ruleSquareBracketedClauseCS ) )
            // InternalEOCL.g:10555:2: ( ruleSquareBracketedClauseCS )
            {
            // InternalEOCL.g:10555:2: ( ruleSquareBracketedClauseCS )
            // InternalEOCL.g:10556:3: ruleSquareBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10565:1: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10569:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalEOCL.g:10570:2: ( ruleRoundBracketedClauseCS )
            {
            // InternalEOCL.g:10570:2: ( ruleRoundBracketedClauseCS )
            // InternalEOCL.g:10571:3: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10580:1: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10584:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalEOCL.g:10585:2: ( ruleCurlyBracketedClauseCS )
            {
            // InternalEOCL.g:10585:2: ( ruleCurlyBracketedClauseCS )
            // InternalEOCL.g:10586:3: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10595:1: rule__NameExpCS__IsPreAssignment_4_0 : ( ( '@' ) ) ;
    public final void rule__NameExpCS__IsPreAssignment_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10599:1: ( ( ( '@' ) ) )
            // InternalEOCL.g:10600:2: ( ( '@' ) )
            {
            // InternalEOCL.g:10600:2: ( ( '@' ) )
            // InternalEOCL.g:10601:3: ( '@' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); 
            }
            // InternalEOCL.g:10602:3: ( '@' )
            // InternalEOCL.g:10603:4: '@'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0()); 
            }
            match(input,81,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_0"
    // InternalEOCL.g:10614:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10618:1: ( ( ruleShadowPartCS ) )
            // InternalEOCL.g:10619:2: ( ruleShadowPartCS )
            {
            // InternalEOCL.g:10619:2: ( ruleShadowPartCS )
            // InternalEOCL.g:10620:3: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleShadowPartCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1"
    // InternalEOCL.g:10629:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10633:1: ( ( ruleShadowPartCS ) )
            // InternalEOCL.g:10634:2: ( ruleShadowPartCS )
            {
            // InternalEOCL.g:10634:2: ( ruleShadowPartCS )
            // InternalEOCL.g:10635:3: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleShadowPartCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CurlyBracketedClauseCS__ValueAssignment_2_1"
    // InternalEOCL.g:10644:1: rule__CurlyBracketedClauseCS__ValueAssignment_2_1 : ( ruleStringLiteral ) ;
    public final void rule__CurlyBracketedClauseCS__ValueAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10648:1: ( ( ruleStringLiteral ) )
            // InternalEOCL.g:10649:2: ( ruleStringLiteral )
            {
            // InternalEOCL.g:10649:2: ( ruleStringLiteral )
            // InternalEOCL.g:10650:3: ruleStringLiteral
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getValueStringLiteralParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleStringLiteral();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0"
    // InternalEOCL.g:10659:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 : ( ruleNavigatingArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10663:1: ( ( ruleNavigatingArgCS ) )
            // InternalEOCL.g:10664:2: ( ruleNavigatingArgCS )
            {
            // InternalEOCL.g:10664:2: ( ruleNavigatingArgCS )
            // InternalEOCL.g:10665:3: ruleNavigatingArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10674:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 : ( ruleNavigatingCommaArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10678:1: ( ( ruleNavigatingCommaArgCS ) )
            // InternalEOCL.g:10679:2: ( ruleNavigatingCommaArgCS )
            {
            // InternalEOCL.g:10679:2: ( ruleNavigatingCommaArgCS )
            // InternalEOCL.g:10680:3: ruleNavigatingCommaArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigatingCommaArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_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__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0"
    // InternalEOCL.g:10689:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0 : ( ruleNavigatingSemiArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10693:1: ( ( ruleNavigatingSemiArgCS ) )
            // InternalEOCL.g:10694:2: ( ruleNavigatingSemiArgCS )
            {
            // InternalEOCL.g:10694:2: ( ruleNavigatingSemiArgCS )
            // InternalEOCL.g:10695:3: ruleNavigatingSemiArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_2_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigatingSemiArgCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1"
    // InternalEOCL.g:10704:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1 : ( ruleNavigatingCommaArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10708:1: ( ( ruleNavigatingCommaArgCS ) )
            // InternalEOCL.g:10709:2: ( ruleNavigatingCommaArgCS )
            {
            // InternalEOCL.g:10709:2: ( ruleNavigatingCommaArgCS )
            // InternalEOCL.g:10710:3: ruleNavigatingCommaArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigatingCommaArgCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0"
    // InternalEOCL.g:10719:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0 : ( ruleNavigatingBarArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10723:1: ( ( ruleNavigatingBarArgCS ) )
            // InternalEOCL.g:10724:2: ( ruleNavigatingBarArgCS )
            {
            // InternalEOCL.g:10724:2: ( ruleNavigatingBarArgCS )
            // InternalEOCL.g:10725:3: ruleNavigatingBarArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_3_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigatingBarArgCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1"
    // InternalEOCL.g:10734:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1 : ( ruleNavigatingCommaArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10738:1: ( ( ruleNavigatingCommaArgCS ) )
            // InternalEOCL.g:10739:2: ( ruleNavigatingCommaArgCS )
            {
            // InternalEOCL.g:10739:2: ( ruleNavigatingCommaArgCS )
            // InternalEOCL.g:10740:3: ruleNavigatingCommaArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigatingCommaArgCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1"
    // InternalEOCL.g:10749:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10753:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10754:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10754:2: ( ruleExpCS )
            // InternalEOCL.g:10755:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10764:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10768:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10769:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10769:2: ( ruleExpCS )
            // InternalEOCL.g:10770:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10779:1: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10783:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEOCL.g:10784:2: ( ruleNavigatingArgExpCS )
            {
            // InternalEOCL.g:10784:2: ( ruleNavigatingArgExpCS )
            // InternalEOCL.g:10785:3: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0()); 
            }
            pushFollow(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__OwnedTypeAssignment_0_1_0_1"
    // InternalEOCL.g:10794:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10798:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10799:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10799:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10800:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_0_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleTypeExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1"
    // InternalEOCL.g:10809: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 {
            // InternalEOCL.g:10813:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10814:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10814:2: ( ruleExpCS )
            // InternalEOCL.g:10815:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0()); 
            }
            pushFollow(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__OwnedInitExpressionAssignment_0_1_1_1"
    // InternalEOCL.g:10824:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10828:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10829:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10829:2: ( ruleExpCS )
            // InternalEOCL.g:10830:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_1_1"
    // InternalEOCL.g:10839:1: rule__NavigatingArgCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10843:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10844:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10844:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10845:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10854:1: rule__NavigatingBarArgCS__PrefixAssignment_0 : ( ( '|' ) ) ;
    public final void rule__NavigatingBarArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10858:1: ( ( ( '|' ) ) )
            // InternalEOCL.g:10859:2: ( ( '|' ) )
            {
            // InternalEOCL.g:10859:2: ( ( '|' ) )
            // InternalEOCL.g:10860:3: ( '|' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); 
            }
            // InternalEOCL.g:10861:3: ( '|' )
            // InternalEOCL.g:10862:4: '|'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0()); 
            }
            match(input,82,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"
    // InternalEOCL.g:10873:1: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10877:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEOCL.g:10878:2: ( ruleNavigatingArgExpCS )
            {
            // InternalEOCL.g:10878:2: ( ruleNavigatingArgExpCS )
            // InternalEOCL.g:10879:3: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10888:1: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10892:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10893:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10893:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10894:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10903:1: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10907:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10908:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10908:2: ( ruleExpCS )
            // InternalEOCL.g:10909:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:10918:1: rule__NavigatingCommaArgCS__PrefixAssignment_0 : ( ( ',' ) ) ;
    public final void rule__NavigatingCommaArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10922:1: ( ( ( ',' ) ) )
            // InternalEOCL.g:10923:2: ( ( ',' ) )
            {
            // InternalEOCL.g:10923:2: ( ( ',' ) )
            // InternalEOCL.g:10924:3: ( ',' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); 
            }
            // InternalEOCL.g:10925:3: ( ',' )
            // InternalEOCL.g:10926:4: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0()); 
            }
            match(input,55,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"
    // InternalEOCL.g:10937:1: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10941:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEOCL.g:10942:2: ( ruleNavigatingArgExpCS )
            {
            // InternalEOCL.g:10942:2: ( ruleNavigatingArgExpCS )
            // InternalEOCL.g:10943:3: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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__OwnedTypeAssignment_2_0_1"
    // InternalEOCL.g:10952:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10956:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:10957:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:10957:2: ( ruleTypeExpCS )
            // InternalEOCL.g:10958:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleTypeExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1"
    // InternalEOCL.g:10967: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 {
            // InternalEOCL.g:10971:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10972:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10972:2: ( ruleExpCS )
            // InternalEOCL.g:10973:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0()); 
            }
            pushFollow(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__OwnedInitExpressionAssignment_2_1_1"
    // InternalEOCL.g:10982:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:10986:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:10987:2: ( ruleExpCS )
            {
            // InternalEOCL.g:10987:2: ( ruleExpCS )
            // InternalEOCL.g:10988:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigatingSemiArgCS__PrefixAssignment_0"
    // InternalEOCL.g:10997:1: rule__NavigatingSemiArgCS__PrefixAssignment_0 : ( ( ';' ) ) ;
    public final void rule__NavigatingSemiArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11001:1: ( ( ( ';' ) ) )
            // InternalEOCL.g:11002:2: ( ( ';' ) )
            {
            // InternalEOCL.g:11002:2: ( ( ';' ) )
            // InternalEOCL.g:11003:3: ( ';' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); 
            }
            // InternalEOCL.g:11004:3: ( ';' )
            // InternalEOCL.g:11005:4: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0()); 
            }
            match(input,83,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"
    // InternalEOCL.g:11016:1: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11020:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalEOCL.g:11021:2: ( ruleNavigatingArgExpCS )
            {
            // InternalEOCL.g:11021:2: ( ruleNavigatingArgExpCS )
            // InternalEOCL.g:11022:3: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11031:1: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11035:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:11036:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:11036:2: ( ruleTypeExpCS )
            // InternalEOCL.g:11037:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11046:1: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11050:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11051:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11051:2: ( ruleExpCS )
            // InternalEOCL.g:11052:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0()); 
            }
            pushFollow(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__IfExpCS__OwnedConditionAssignment_1"
    // InternalEOCL.g:11061:1: rule__IfExpCS__OwnedConditionAssignment_1 : ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) ;
    public final void rule__IfExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11065:1: ( ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) )
            // InternalEOCL.g:11066:2: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            {
            // InternalEOCL.g:11066:2: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            // InternalEOCL.g:11067:3: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0()); 
            }
            // InternalEOCL.g:11068:3: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            // InternalEOCL.g:11068:4: rule__IfExpCS__OwnedConditionAlternatives_1_0
            {
            pushFollow(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"
    // InternalEOCL.g:11076:1: rule__IfExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11080:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11081:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11081:2: ( ruleExpCS )
            // InternalEOCL.g:11082:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11091:1: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 : ( ruleElseIfThenExpCS ) ;
    public final void rule__IfExpCS__OwnedIfThenExpressionsAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11095:1: ( ( ruleElseIfThenExpCS ) )
            // InternalEOCL.g:11096:2: ( ruleElseIfThenExpCS )
            {
            // InternalEOCL.g:11096:2: ( ruleElseIfThenExpCS )
            // InternalEOCL.g:11097:3: ruleElseIfThenExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11106:1: rule__IfExpCS__OwnedElseExpressionAssignment_6 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedElseExpressionAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11110:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11111:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11111:2: ( ruleExpCS )
            // InternalEOCL.g:11112:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11121:1: rule__ElseIfThenExpCS__OwnedConditionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11125:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11126:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11126:2: ( ruleExpCS )
            // InternalEOCL.g:11127:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11136:1: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11140:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11141:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11141:2: ( ruleExpCS )
            // InternalEOCL.g:11142:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11151:1: rule__LetExpCS__OwnedVariablesAssignment_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11155:1: ( ( ruleLetVariableCS ) )
            // InternalEOCL.g:11156:2: ( ruleLetVariableCS )
            {
            // InternalEOCL.g:11156:2: ( ruleLetVariableCS )
            // InternalEOCL.g:11157:3: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11166:1: rule__LetExpCS__OwnedVariablesAssignment_2_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11170:1: ( ( ruleLetVariableCS ) )
            // InternalEOCL.g:11171:2: ( ruleLetVariableCS )
            {
            // InternalEOCL.g:11171:2: ( ruleLetVariableCS )
            // InternalEOCL.g:11172:3: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11181:1: rule__LetExpCS__OwnedInExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetExpCS__OwnedInExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11185:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11186:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11186:2: ( ruleExpCS )
            // InternalEOCL.g:11187:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11196:1: rule__LetVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__LetVariableCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11200:1: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:11201:2: ( ruleUnrestrictedName )
            {
            // InternalEOCL.g:11201:2: ( ruleUnrestrictedName )
            // InternalEOCL.g:11202:3: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11211:1: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11215:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalEOCL.g:11216:2: ( ruleRoundBracketedClauseCS )
            {
            // InternalEOCL.g:11216:2: ( ruleRoundBracketedClauseCS )
            // InternalEOCL.g:11217:3: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11226:1: rule__LetVariableCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__LetVariableCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11230:1: ( ( ruleTypeExpCS ) )
            // InternalEOCL.g:11231:2: ( ruleTypeExpCS )
            {
            // InternalEOCL.g:11231:2: ( ruleTypeExpCS )
            // InternalEOCL.g:11232:3: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11241:1: rule__LetVariableCS__OwnedInitExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetVariableCS__OwnedInitExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11245:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11246:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11246:2: ( ruleExpCS )
            // InternalEOCL.g:11247:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11256:1: rule__NestedExpCS__OwnedExpressionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__NestedExpCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11260:1: ( ( ruleExpCS ) )
            // InternalEOCL.g:11261:2: ( ruleExpCS )
            {
            // InternalEOCL.g:11261:2: ( ruleExpCS )
            // InternalEOCL.g:11262:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11271:1: rule__MultiplicityBoundsCS__LowerBoundAssignment_0 : ( ruleLOWER ) ;
    public final void rule__MultiplicityBoundsCS__LowerBoundAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11275:1: ( ( ruleLOWER ) )
            // InternalEOCL.g:11276:2: ( ruleLOWER )
            {
            // InternalEOCL.g:11276:2: ( ruleLOWER )
            // InternalEOCL.g:11277:3: ruleLOWER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11286:1: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 : ( ruleUPPER ) ;
    public final void rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11290:1: ( ( ruleUPPER ) )
            // InternalEOCL.g:11291:2: ( ruleUPPER )
            {
            // InternalEOCL.g:11291:2: ( ruleUPPER )
            // InternalEOCL.g:11292:3: ruleUPPER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11301:1: rule__MultiplicityCS__IsNullFreeAssignment_2_1 : ( ( '|1' ) ) ;
    public final void rule__MultiplicityCS__IsNullFreeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11305:1: ( ( ( '|1' ) ) )
            // InternalEOCL.g:11306:2: ( ( '|1' ) )
            {
            // InternalEOCL.g:11306:2: ( ( '|1' ) )
            // InternalEOCL.g:11307:3: ( '|1' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); 
            }
            // InternalEOCL.g:11308:3: ( '|1' )
            // InternalEOCL.g:11309:4: '|1'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0()); 
            }
            match(input,84,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"
    // InternalEOCL.g:11320:1: rule__MultiplicityStringCS__StringBoundsAssignment : ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) ;
    public final void rule__MultiplicityStringCS__StringBoundsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11324:1: ( ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) )
            // InternalEOCL.g:11325:2: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            {
            // InternalEOCL.g:11325:2: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            // InternalEOCL.g:11326:3: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0()); 
            }
            // InternalEOCL.g:11327:3: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            // InternalEOCL.g:11327:4: rule__MultiplicityStringCS__StringBoundsAlternatives_0
            {
            pushFollow(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"
    // InternalEOCL.g:11335:1: rule__PathNameCS__OwnedPathElementsAssignment_0 : ( ruleFirstPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11339:1: ( ( ruleFirstPathElementCS ) )
            // InternalEOCL.g:11340:2: ( ruleFirstPathElementCS )
            {
            // InternalEOCL.g:11340:2: ( ruleFirstPathElementCS )
            // InternalEOCL.g:11341:3: ruleFirstPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11350:1: rule__PathNameCS__OwnedPathElementsAssignment_1_1 : ( ruleNextPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11354:1: ( ( ruleNextPathElementCS ) )
            // InternalEOCL.g:11355:2: ( ruleNextPathElementCS )
            {
            // InternalEOCL.g:11355:2: ( ruleNextPathElementCS )
            // InternalEOCL.g:11356:3: ruleNextPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11365:1: rule__FirstPathElementCS__ReferredElementAssignment : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__FirstPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11369:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalEOCL.g:11370:2: ( ( ruleUnrestrictedName ) )
            {
            // InternalEOCL.g:11370:2: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:11371:3: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); 
            }
            // InternalEOCL.g:11372:3: ( ruleUnrestrictedName )
            // InternalEOCL.g:11373:4: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11384:1: rule__NextPathElementCS__ReferredElementAssignment : ( ( ruleUnreservedName ) ) ;
    public final void rule__NextPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11388:1: ( ( ( ruleUnreservedName ) ) )
            // InternalEOCL.g:11389:2: ( ( ruleUnreservedName ) )
            {
            // InternalEOCL.g:11389:2: ( ( ruleUnreservedName ) )
            // InternalEOCL.g:11390:3: ( ruleUnreservedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0()); 
            }
            // InternalEOCL.g:11391:3: ( ruleUnreservedName )
            // InternalEOCL.g:11392:4: ruleUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11403:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11407:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalEOCL.g:11408:2: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalEOCL.g:11408:2: ( ruleTemplateParameterSubstitutionCS )
            // InternalEOCL.g:11409:3: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11418:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11422:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalEOCL.g:11423:2: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalEOCL.g:11423:2: ( ruleTemplateParameterSubstitutionCS )
            // InternalEOCL.g:11424:3: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11433:1: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 : ( ruleMultiplicityCS ) ;
    public final void rule__TemplateBindingCS__OwnedMultiplicityAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11437:1: ( ( ruleMultiplicityCS ) )
            // InternalEOCL.g:11438:2: ( ruleMultiplicityCS )
            {
            // InternalEOCL.g:11438:2: ( ruleMultiplicityCS )
            // InternalEOCL.g:11439:3: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11448:1: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment : ( ruleTypeRefCS ) ;
    public final void rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11452:1: ( ( ruleTypeRefCS ) )
            // InternalEOCL.g:11453:2: ( ruleTypeRefCS )
            {
            // InternalEOCL.g:11453:2: ( ruleTypeRefCS )
            // InternalEOCL.g:11454:3: ruleTypeRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11463:1: rule__TypeParameterCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TypeParameterCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11467:1: ( ( ruleUnrestrictedName ) )
            // InternalEOCL.g:11468:2: ( ruleUnrestrictedName )
            {
            // InternalEOCL.g:11468:2: ( ruleUnrestrictedName )
            // InternalEOCL.g:11469:3: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11478:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11482:1: ( ( ruleTypedRefCS ) )
            // InternalEOCL.g:11483:2: ( ruleTypedRefCS )
            {
            // InternalEOCL.g:11483:2: ( ruleTypedRefCS )
            // InternalEOCL.g:11484:3: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11493:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11497:1: ( ( ruleTypedRefCS ) )
            // InternalEOCL.g:11498:2: ( ruleTypedRefCS )
            {
            // InternalEOCL.g:11498:2: ( ruleTypedRefCS )
            // InternalEOCL.g:11499:3: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11508:1: rule__TypedTypeRefCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypedTypeRefCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11512:1: ( ( rulePathNameCS ) )
            // InternalEOCL.g:11513:2: ( rulePathNameCS )
            {
            // InternalEOCL.g:11513:2: ( rulePathNameCS )
            // InternalEOCL.g:11514:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11523:1: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 : ( ruleTemplateBindingCS ) ;
    public final void rule__TypedTypeRefCS__OwnedBindingAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11527:1: ( ( ruleTemplateBindingCS ) )
            // InternalEOCL.g:11528:2: ( ruleTemplateBindingCS )
            {
            // InternalEOCL.g:11528:2: ( ruleTemplateBindingCS )
            // InternalEOCL.g:11529:3: ruleTemplateBindingCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0()); 
            }
            pushFollow(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"
    // InternalEOCL.g:11538:1: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalEOCL.g:11542:1: ( ( ruleTypedRefCS ) )
            // InternalEOCL.g:11543:2: ( ruleTypedRefCS )
            {
            // InternalEOCL.g:11543:2: ( ruleTypedRefCS )
            // InternalEOCL.g:11544:3: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0()); 
            }
            pushFollow(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 synpred48_InternalEOCL
    public final void synpred48_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2586:2: ( ( ruleTypeLiteralCS ) )
        // InternalEOCL.g:2586:2: ( ruleTypeLiteralCS )
        {
        // InternalEOCL.g:2586:2: ( ruleTypeLiteralCS )
        // InternalEOCL.g:2587:3: ruleTypeLiteralCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getTypeExpCSAccess().getTypeLiteralCSParserRuleCall_0_1()); 
        }
        pushFollow(FOLLOW_2);
        ruleTypeLiteralCS();

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

        }


        }
    }
    // $ANTLR end synpred48_InternalEOCL

    // $ANTLR start synpred49_InternalEOCL
    public final void synpred49_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2607:2: ( ( ( rule__ExpCS__Group_0__0 ) ) )
        // InternalEOCL.g:2607:2: ( ( rule__ExpCS__Group_0__0 ) )
        {
        // InternalEOCL.g:2607:2: ( ( rule__ExpCS__Group_0__0 ) )
        // InternalEOCL.g:2608:3: ( rule__ExpCS__Group_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getExpCSAccess().getGroup_0()); 
        }
        // InternalEOCL.g:2609:3: ( rule__ExpCS__Group_0__0 )
        // InternalEOCL.g:2609:4: rule__ExpCS__Group_0__0
        {
        pushFollow(FOLLOW_2);
        rule__ExpCS__Group_0__0();

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

        }


        }


        }
    }
    // $ANTLR end synpred49_InternalEOCL

    // $ANTLR start synpred56_InternalEOCL
    public final void synpred56_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2694:2: ( ( ruleTupleLiteralExpCS ) )
        // InternalEOCL.g:2694:2: ( ruleTupleLiteralExpCS )
        {
        // InternalEOCL.g:2694:2: ( ruleTupleLiteralExpCS )
        // InternalEOCL.g:2695:3: ruleTupleLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4()); 
        }
        pushFollow(FOLLOW_2);
        ruleTupleLiteralExpCS();

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

        }


        }
    }
    // $ANTLR end synpred56_InternalEOCL

    // $ANTLR start synpred57_InternalEOCL
    public final void synpred57_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2700:2: ( ( ruleMapLiteralExpCS ) )
        // InternalEOCL.g:2700:2: ( ruleMapLiteralExpCS )
        {
        // InternalEOCL.g:2700:2: ( ruleMapLiteralExpCS )
        // InternalEOCL.g:2701:3: ruleMapLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5()); 
        }
        pushFollow(FOLLOW_2);
        ruleMapLiteralExpCS();

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

        }


        }
    }
    // $ANTLR end synpred57_InternalEOCL

    // $ANTLR start synpred58_InternalEOCL
    public final void synpred58_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2706:2: ( ( ruleCollectionLiteralExpCS ) )
        // InternalEOCL.g:2706:2: ( ruleCollectionLiteralExpCS )
        {
        // InternalEOCL.g:2706:2: ( ruleCollectionLiteralExpCS )
        // InternalEOCL.g:2707:3: ruleCollectionLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6()); 
        }
        pushFollow(FOLLOW_2);
        ruleCollectionLiteralExpCS();

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

        }


        }
    }
    // $ANTLR end synpred58_InternalEOCL

    // $ANTLR start synpred60_InternalEOCL
    public final void synpred60_InternalEOCL_fragment() throws RecognitionException {   
        // InternalEOCL.g:2718:2: ( ( ruleTypeLiteralExpCS ) )
        // InternalEOCL.g:2718:2: ( ruleTypeLiteralExpCS )
        {
        // InternalEOCL.g:2718:2: ( ruleTypeLiteralExpCS )
        // InternalEOCL.g:2719:3: ruleTypeLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8()); 
        }
        pushFollow(FOLLOW_2);
        ruleTypeLiteralExpCS();

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

        }


        }
    }
    // $ANTLR end synpred60_InternalEOCL

    // Delegated rules

    public final boolean synpred57_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred57_InternalEOCL_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 synpred58_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred58_InternalEOCL_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_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred56_InternalEOCL_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 synpred60_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred60_InternalEOCL_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 synpred48_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred48_InternalEOCL_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 synpred49_InternalEOCL() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred49_InternalEOCL_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 DFA15 dfa15 = new DFA15(this);
    protected DFA16 dfa16 = new DFA16(this);
    protected DFA19 dfa19 = new DFA19(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\61\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\33\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 DFA15 extends DFA {

        public DFA15(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 15;
            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 "2575:1: rule__TypeExpCS__Alternatives_0 : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 : 
                        int LA15_11 = input.LA(1);

                         
                        int index15_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred48_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}

                         
                        input.seek(index15_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA15_12 = input.LA(1);

                         
                        int index15_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred48_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}

                         
                        input.seek(index15_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA15_13 = input.LA(1);

                         
                        int index15_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred48_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}

                         
                        input.seek(index15_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA15_14 = input.LA(1);

                         
                        int index15_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred48_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}

                         
                        input.seek(index15_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA15_15 = input.LA(1);

                         
                        int index15_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred48_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}

                         
                        input.seek(index15_15);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 15, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_7s = "\40\uffff";
    static final String dfa_8s = "\1\4\2\0\35\uffff";
    static final String dfa_9s = "\1\120\2\0\35\uffff";
    static final String dfa_10s = "\3\uffff\1\1\33\uffff\1\2";
    static final String dfa_11s = "\1\uffff\1\0\1\1\35\uffff}>";
    static final String[] dfa_12s = {
            "\4\3\10\uffff\1\1\1\2\1\3\20\uffff\17\3\3\uffff\1\3\7\uffff\1\3\1\uffff\2\3\4\uffff\1\3\4\uffff\1\37\1\3\3\uffff\2\3",
            "\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 DFA16 extends DFA {

        public DFA16(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 16;
            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 "2602: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 LA16_1 = input.LA(1);

                         
                        int index16_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred49_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 31;}

                         
                        input.seek(index16_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA16_2 = input.LA(1);

                         
                        int index16_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred49_InternalEOCL()) ) {s = 3;}

                        else if ( (true) ) {s = 31;}

                         
                        input.seek(index16_2);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 16, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_13s = "\1\4\12\uffff\7\0\16\uffff";
    static final String dfa_14s = "\1\120\12\uffff\7\0\16\uffff";
    static final String dfa_15s = "\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_16s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\16\uffff}>";
    static final String[] dfa_17s = {
            "\2\4\2\33\12\uffff\1\4\20\uffff\1\14\1\13\10\23\1\15\1\16\1\17\1\20\1\21\3\uffff\1\1\7\uffff\1\22\1\uffff\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 char[] dfa_13 = DFA.unpackEncodedStringToUnsignedChars(dfa_13s);
    static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s);
    static final short[] dfa_15 = DFA.unpackEncodedString(dfa_15s);
    static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s);
    static final short[][] dfa_17 = unpackEncodedStringArray(dfa_17s);

    class DFA19 extends DFA {

        public DFA19(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 19;
            this.eot = dfa_7;
            this.eof = dfa_7;
            this.min = dfa_13;
            this.max = dfa_14;
            this.accept = dfa_15;
            this.special = dfa_16;
            this.transition = dfa_17;
        }
        public String getDescription() {
            return "2665: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 LA19_11 = input.LA(1);

                         
                        int index19_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred56_InternalEOCL()) ) {s = 29;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 : 
                        int LA19_12 = input.LA(1);

                         
                        int index19_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred57_InternalEOCL()) ) {s = 30;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 : 
                        int LA19_13 = input.LA(1);

                         
                        int index19_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred58_InternalEOCL()) ) {s = 31;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 : 
                        int LA19_14 = input.LA(1);

                         
                        int index19_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred58_InternalEOCL()) ) {s = 31;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 : 
                        int LA19_15 = input.LA(1);

                         
                        int index19_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred58_InternalEOCL()) ) {s = 31;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_15);
                        if ( s>=0 ) return s;
                        break;
                    case 5 : 
                        int LA19_16 = input.LA(1);

                         
                        int index19_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred58_InternalEOCL()) ) {s = 31;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_16);
                        if ( s>=0 ) return s;
                        break;
                    case 6 : 
                        int LA19_17 = input.LA(1);

                         
                        int index19_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred58_InternalEOCL()) ) {s = 31;}

                        else if ( (synpred60_InternalEOCL()) ) {s = 19;}

                         
                        input.seek(index19_17);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 19, _s, input);
            error(nvae);
            throw nvae;
        }
    }
 

    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[]{0xA023FFF8000700F0L,0x0000000000018C21L});
    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0020000000000000L});
    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0xA023FFF8000700F0L,0x0000000000018821L});
    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0040000000000000L});
    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0080000000000000L});
    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0xA063FFF8000700F0L,0x0000000000018821L});
    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0080000000000002L});
    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0100000000000000L});
    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0200000000000000L});
    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0xA523FFF8000700F0L,0x0000000000018C21L});
    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0xA123FFF8000700F0L,0x0000000000018C21L});
    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0800000000000000L});
    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x1080000000000000L});
    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000002000000L});
    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0400000000000000L});
    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0xA423FFF8000700F0L,0x0000000000018C21L});
    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x4000000000000000L});
    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0480000000000000L});
    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0100000002000000L});
    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x8000000000000000L});
    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x8000000000040030L,0x0000000000018001L});
    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x00000007FFFD0000L});
    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000030000L});
    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0220000000000000L,0x0000000000020004L});
    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000004L});
    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000002L});
    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0xA163FFF8000700F0L,0x0000000000018C21L});
    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0080000000000000L,0x00000000000C0000L});
    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000002L,0x0000000000040000L});
    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0080000000000000L,0x0000000000000008L});
    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0100000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000280L});
    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000200L});
    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0080000000000000L,0x0000000000000010L});
    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0120000002000000L});
    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000040010L});
    public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0008000000140010L});
    public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x0004000000000000L,0x0000000000100008L});
    public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x0000000000000000L,0x0000000000001000L});
    public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000002L,0x0000000000001000L});
    public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x0080000000000000L,0x0000000000000004L});
    public static final BitSet FOLLOW_51 = new BitSet(new long[]{0xA02BFFF8000700F0L,0x0000000000018821L});
    public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x0000000000000000L,0x0000000000002000L});
    public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
    public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000002L,0x0000000000004000L});

}