/*******************************************************************************
 * Copyright (c) 2018 Willink Transformations and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Adolfo Sanchez-Barbudo Herrera - initial API and implementation
 *******************************************************************************/
package org.eclipse.qvtd.doc.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.eclipse.qvtd.doc.services.MiniOCLCSGrammarAccess;


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 InternalMiniOCLCSParser extends AbstractInternalContentAssistParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_STRING", "RULE_INT", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'Collection'", "'='", "'<>'", "'.'", "'->'", "'false'", "'import'", "';'", "':'", "'package'", "'{'", "'}'", "'class'", "'extends'", "'prop'", "'['", "']'", "'..'", "'op'", "'('", "')'", "','", "'context'", "'inv'", "'self'", "'collect'", "'|'", "'iterate'", "'null'", "'let'", "'in'", "'::'", "'?'", "'*'", "'true'"
    };
    public static final int T__19=19;
    public static final int T__15=15;
    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__11=11;
    public static final int T__12=12;
    public static final int T__13=13;
    public static final int T__14=14;
    public static final int RULE_ID=4;
    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=6;
    public static final int T__29=29;
    public static final int T__22=22;
    public static final int RULE_ML_COMMENT=7;
    public static final int T__23=23;
    public static final int T__24=24;
    public static final int T__25=25;
    public static final int T__20=20;
    public static final int T__21=21;
    public static final int RULE_STRING=5;
    public static final int RULE_SL_COMMENT=8;
    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__34=34;
    public static final int T__35=35;
    public static final int T__36=36;
    public static final int EOF=-1;
    public static final int T__30=30;
    public static final int T__31=31;
    public static final int T__32=32;
    public static final int RULE_WS=9;
    public static final int RULE_ANY_OTHER=10;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int T__42=42;
    public static final int T__43=43;

    // delegates
    // delegators


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

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


    	private MiniOCLCSGrammarAccess grammarAccess;

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

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

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


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

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

            }

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


    // $ANTLR start "ruleRootCS"
    // InternalMiniOCLCS.g:63:1: ruleRootCS : ( ( rule__RootCS__Group__0 ) ) ;
    public final void ruleRootCS() throws RecognitionException {

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

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleImportCS"
    // InternalMiniOCLCS.g:88:1: ruleImportCS : ( ( rule__ImportCS__Group__0 ) ) ;
    public final void ruleImportCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:92:2: ( ( ( rule__ImportCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:93:2: ( ( rule__ImportCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:93:2: ( ( rule__ImportCS__Group__0 ) )
            // InternalMiniOCLCS.g:94:3: ( rule__ImportCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:95:3: ( rule__ImportCS__Group__0 )
            // InternalMiniOCLCS.g:95:4: rule__ImportCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePackageCS"
    // InternalMiniOCLCS.g:104:1: entryRulePackageCS : rulePackageCS EOF ;
    public final void entryRulePackageCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:105:1: ( rulePackageCS EOF )
            // InternalMiniOCLCS.g:106:1: rulePackageCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePackageCS();

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

            }

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


    // $ANTLR start "rulePackageCS"
    // InternalMiniOCLCS.g:113:1: rulePackageCS : ( ( rule__PackageCS__Group__0 ) ) ;
    public final void rulePackageCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:117:2: ( ( ( rule__PackageCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:118:2: ( ( rule__PackageCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:118:2: ( ( rule__PackageCS__Group__0 ) )
            // InternalMiniOCLCS.g:119:3: ( rule__PackageCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:120:3: ( rule__PackageCS__Group__0 )
            // InternalMiniOCLCS.g:120:4: rule__PackageCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__PackageCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleClassCS"
    // InternalMiniOCLCS.g:129:1: entryRuleClassCS : ruleClassCS EOF ;
    public final void entryRuleClassCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:130:1: ( ruleClassCS EOF )
            // InternalMiniOCLCS.g:131:1: ruleClassCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleClassCS();

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

            }

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


    // $ANTLR start "ruleClassCS"
    // InternalMiniOCLCS.g:138:1: ruleClassCS : ( ( rule__ClassCS__Group__0 ) ) ;
    public final void ruleClassCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:142:2: ( ( ( rule__ClassCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:143:2: ( ( rule__ClassCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:143:2: ( ( rule__ClassCS__Group__0 ) )
            // InternalMiniOCLCS.g:144:3: ( rule__ClassCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:145:3: ( rule__ClassCS__Group__0 )
            // InternalMiniOCLCS.g:145:4: rule__ClassCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ClassCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePropertyCS"
    // InternalMiniOCLCS.g:154:1: entryRulePropertyCS : rulePropertyCS EOF ;
    public final void entryRulePropertyCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:155:1: ( rulePropertyCS EOF )
            // InternalMiniOCLCS.g:156:1: rulePropertyCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePropertyCS();

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

            }

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


    // $ANTLR start "rulePropertyCS"
    // InternalMiniOCLCS.g:163:1: rulePropertyCS : ( ( rule__PropertyCS__Group__0 ) ) ;
    public final void rulePropertyCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:167:2: ( ( ( rule__PropertyCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:168:2: ( ( rule__PropertyCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:168:2: ( ( rule__PropertyCS__Group__0 ) )
            // InternalMiniOCLCS.g:169:3: ( rule__PropertyCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:170:3: ( rule__PropertyCS__Group__0 )
            // InternalMiniOCLCS.g:170:4: rule__PropertyCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__PropertyCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleMultiplicityCS"
    // InternalMiniOCLCS.g:179:1: entryRuleMultiplicityCS : ruleMultiplicityCS EOF ;
    public final void entryRuleMultiplicityCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:180:1: ( ruleMultiplicityCS EOF )
            // InternalMiniOCLCS.g:181: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"
    // InternalMiniOCLCS.g:188:1: ruleMultiplicityCS : ( ( rule__MultiplicityCS__Group__0 ) ) ;
    public final void ruleMultiplicityCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:192:2: ( ( ( rule__MultiplicityCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:193:2: ( ( rule__MultiplicityCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:193:2: ( ( rule__MultiplicityCS__Group__0 ) )
            // InternalMiniOCLCS.g:194:3: ( rule__MultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:195:3: ( rule__MultiplicityCS__Group__0 )
            // InternalMiniOCLCS.g:195: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 "entryRuleOperationCS"
    // InternalMiniOCLCS.g:204:1: entryRuleOperationCS : ruleOperationCS EOF ;
    public final void entryRuleOperationCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:205:1: ( ruleOperationCS EOF )
            // InternalMiniOCLCS.g:206:1: ruleOperationCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOperationCS();

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

            }

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


    // $ANTLR start "ruleOperationCS"
    // InternalMiniOCLCS.g:213:1: ruleOperationCS : ( ( rule__OperationCS__Group__0 ) ) ;
    public final void ruleOperationCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:217:2: ( ( ( rule__OperationCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:218:2: ( ( rule__OperationCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:218:2: ( ( rule__OperationCS__Group__0 ) )
            // InternalMiniOCLCS.g:219:3: ( rule__OperationCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:220:3: ( rule__OperationCS__Group__0 )
            // InternalMiniOCLCS.g:220:4: rule__OperationCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleParameterCS"
    // InternalMiniOCLCS.g:229:1: entryRuleParameterCS : ruleParameterCS EOF ;
    public final void entryRuleParameterCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:230:1: ( ruleParameterCS EOF )
            // InternalMiniOCLCS.g:231:1: ruleParameterCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleParameterCS();

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

            }

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


    // $ANTLR start "ruleParameterCS"
    // InternalMiniOCLCS.g:238:1: ruleParameterCS : ( ( rule__ParameterCS__Group__0 ) ) ;
    public final void ruleParameterCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:242:2: ( ( ( rule__ParameterCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:243:2: ( ( rule__ParameterCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:243:2: ( ( rule__ParameterCS__Group__0 ) )
            // InternalMiniOCLCS.g:244:3: ( rule__ParameterCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:245:3: ( rule__ParameterCS__Group__0 )
            // InternalMiniOCLCS.g:245:4: rule__ParameterCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ParameterCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleConstraintsDefCS"
    // InternalMiniOCLCS.g:254:1: entryRuleConstraintsDefCS : ruleConstraintsDefCS EOF ;
    public final void entryRuleConstraintsDefCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:255:1: ( ruleConstraintsDefCS EOF )
            // InternalMiniOCLCS.g:256:1: ruleConstraintsDefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleConstraintsDefCS();

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

            }

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


    // $ANTLR start "ruleConstraintsDefCS"
    // InternalMiniOCLCS.g:263:1: ruleConstraintsDefCS : ( ( rule__ConstraintsDefCS__Group__0 ) ) ;
    public final void ruleConstraintsDefCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:267:2: ( ( ( rule__ConstraintsDefCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:268:2: ( ( rule__ConstraintsDefCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:268:2: ( ( rule__ConstraintsDefCS__Group__0 ) )
            // InternalMiniOCLCS.g:269:3: ( rule__ConstraintsDefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:270:3: ( rule__ConstraintsDefCS__Group__0 )
            // InternalMiniOCLCS.g:270:4: rule__ConstraintsDefCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__ConstraintsDefCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleInvariantCS"
    // InternalMiniOCLCS.g:279:1: entryRuleInvariantCS : ruleInvariantCS EOF ;
    public final void entryRuleInvariantCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:280:1: ( ruleInvariantCS EOF )
            // InternalMiniOCLCS.g:281:1: ruleInvariantCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleInvariantCS();

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

            }

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


    // $ANTLR start "ruleInvariantCS"
    // InternalMiniOCLCS.g:288:1: ruleInvariantCS : ( ( rule__InvariantCS__Group__0 ) ) ;
    public final void ruleInvariantCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:292:2: ( ( ( rule__InvariantCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:293:2: ( ( rule__InvariantCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:293:2: ( ( rule__InvariantCS__Group__0 ) )
            // InternalMiniOCLCS.g:294:3: ( rule__InvariantCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:295:3: ( rule__InvariantCS__Group__0 )
            // InternalMiniOCLCS.g:295:4: rule__InvariantCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__InvariantCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleExpCS"
    // InternalMiniOCLCS.g:304:1: entryRuleExpCS : ruleExpCS EOF ;
    public final void entryRuleExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:305:1: ( ruleExpCS EOF )
            // InternalMiniOCLCS.g:306: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"
    // InternalMiniOCLCS.g:313:1: ruleExpCS : ( ruleEqualityExpCS ) ;
    public final void ruleExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:317:2: ( ( ruleEqualityExpCS ) )
            // InternalMiniOCLCS.g:318:2: ( ruleEqualityExpCS )
            {
            // InternalMiniOCLCS.g:318:2: ( ruleEqualityExpCS )
            // InternalMiniOCLCS.g:319:3: ruleEqualityExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getEqualityExpCSParserRuleCall()); 
            }
            pushFollow(FOLLOW_2);
            ruleEqualityExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEqualityExpCS"
    // InternalMiniOCLCS.g:329:1: entryRuleEqualityExpCS : ruleEqualityExpCS EOF ;
    public final void entryRuleEqualityExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:330:1: ( ruleEqualityExpCS EOF )
            // InternalMiniOCLCS.g:331:1: ruleEqualityExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEqualityExpCS();

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

            }

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


    // $ANTLR start "ruleEqualityExpCS"
    // InternalMiniOCLCS.g:338:1: ruleEqualityExpCS : ( ( rule__EqualityExpCS__Group__0 ) ) ;
    public final void ruleEqualityExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:342:2: ( ( ( rule__EqualityExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:343:2: ( ( rule__EqualityExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:343:2: ( ( rule__EqualityExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:344:3: ( rule__EqualityExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:345:3: ( rule__EqualityExpCS__Group__0 )
            // InternalMiniOCLCS.g:345:4: rule__EqualityExpCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCallExpCS"
    // InternalMiniOCLCS.g:354:1: entryRuleCallExpCS : ruleCallExpCS EOF ;
    public final void entryRuleCallExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:355:1: ( ruleCallExpCS EOF )
            // InternalMiniOCLCS.g:356:1: ruleCallExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCallExpCS();

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

            }

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


    // $ANTLR start "ruleCallExpCS"
    // InternalMiniOCLCS.g:363:1: ruleCallExpCS : ( ( rule__CallExpCS__Group__0 ) ) ;
    public final void ruleCallExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:367:2: ( ( ( rule__CallExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:368:2: ( ( rule__CallExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:368:2: ( ( rule__CallExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:369:3: ( rule__CallExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:370:3: ( rule__CallExpCS__Group__0 )
            // InternalMiniOCLCS.g:370:4: rule__CallExpCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePrimaryExpCS"
    // InternalMiniOCLCS.g:379:1: entryRulePrimaryExpCS : rulePrimaryExpCS EOF ;
    public final void entryRulePrimaryExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:380:1: ( rulePrimaryExpCS EOF )
            // InternalMiniOCLCS.g:381: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"
    // InternalMiniOCLCS.g:388:1: rulePrimaryExpCS : ( ( rule__PrimaryExpCS__Alternatives ) ) ;
    public final void rulePrimaryExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:392:2: ( ( ( rule__PrimaryExpCS__Alternatives ) ) )
            // InternalMiniOCLCS.g:393:2: ( ( rule__PrimaryExpCS__Alternatives ) )
            {
            // InternalMiniOCLCS.g:393:2: ( ( rule__PrimaryExpCS__Alternatives ) )
            // InternalMiniOCLCS.g:394:3: ( rule__PrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSAccess().getAlternatives()); 
            }
            // InternalMiniOCLCS.g:395:3: ( rule__PrimaryExpCS__Alternatives )
            // InternalMiniOCLCS.g:395: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 "entryRuleSelfExpCS"
    // InternalMiniOCLCS.g:404:1: entryRuleSelfExpCS : ruleSelfExpCS EOF ;
    public final void entryRuleSelfExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:405:1: ( ruleSelfExpCS EOF )
            // InternalMiniOCLCS.g:406: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"
    // InternalMiniOCLCS.g:413:1: ruleSelfExpCS : ( ( rule__SelfExpCS__Group__0 ) ) ;
    public final void ruleSelfExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:417:2: ( ( ( rule__SelfExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:418:2: ( ( rule__SelfExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:418:2: ( ( rule__SelfExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:419:3: ( rule__SelfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:420:3: ( rule__SelfExpCS__Group__0 )
            // InternalMiniOCLCS.g:420: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 "entryRuleNavigationExpCS"
    // InternalMiniOCLCS.g:429:1: entryRuleNavigationExpCS : ruleNavigationExpCS EOF ;
    public final void entryRuleNavigationExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:430:1: ( ruleNavigationExpCS EOF )
            // InternalMiniOCLCS.g:431:1: ruleNavigationExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNavigationExpCS();

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

            }

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


    // $ANTLR start "ruleNavigationExpCS"
    // InternalMiniOCLCS.g:438:1: ruleNavigationExpCS : ( ( rule__NavigationExpCS__Alternatives ) ) ;
    public final void ruleNavigationExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:442:2: ( ( ( rule__NavigationExpCS__Alternatives ) ) )
            // InternalMiniOCLCS.g:443:2: ( ( rule__NavigationExpCS__Alternatives ) )
            {
            // InternalMiniOCLCS.g:443:2: ( ( rule__NavigationExpCS__Alternatives ) )
            // InternalMiniOCLCS.g:444:3: ( rule__NavigationExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationExpCSAccess().getAlternatives()); 
            }
            // InternalMiniOCLCS.g:445:3: ( rule__NavigationExpCS__Alternatives )
            // InternalMiniOCLCS.g:445:4: rule__NavigationExpCS__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__NavigationExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLoopExpCS"
    // InternalMiniOCLCS.g:454:1: entryRuleLoopExpCS : ruleLoopExpCS EOF ;
    public final void entryRuleLoopExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:455:1: ( ruleLoopExpCS EOF )
            // InternalMiniOCLCS.g:456:1: ruleLoopExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLoopExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLoopExpCS();

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

            }

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


    // $ANTLR start "ruleLoopExpCS"
    // InternalMiniOCLCS.g:463:1: ruleLoopExpCS : ( ( rule__LoopExpCS__Alternatives ) ) ;
    public final void ruleLoopExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:467:2: ( ( ( rule__LoopExpCS__Alternatives ) ) )
            // InternalMiniOCLCS.g:468:2: ( ( rule__LoopExpCS__Alternatives ) )
            {
            // InternalMiniOCLCS.g:468:2: ( ( rule__LoopExpCS__Alternatives ) )
            // InternalMiniOCLCS.g:469:3: ( rule__LoopExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLoopExpCSAccess().getAlternatives()); 
            }
            // InternalMiniOCLCS.g:470:3: ( rule__LoopExpCS__Alternatives )
            // InternalMiniOCLCS.g:470:4: rule__LoopExpCS__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__LoopExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCollectExpCS"
    // InternalMiniOCLCS.g:479:1: entryRuleCollectExpCS : ruleCollectExpCS EOF ;
    public final void entryRuleCollectExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:480:1: ( ruleCollectExpCS EOF )
            // InternalMiniOCLCS.g:481:1: ruleCollectExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCollectExpCS();

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

            }

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


    // $ANTLR start "ruleCollectExpCS"
    // InternalMiniOCLCS.g:488:1: ruleCollectExpCS : ( ( rule__CollectExpCS__Group__0 ) ) ;
    public final void ruleCollectExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:492:2: ( ( ( rule__CollectExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:493:2: ( ( rule__CollectExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:493:2: ( ( rule__CollectExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:494:3: ( rule__CollectExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:495:3: ( rule__CollectExpCS__Group__0 )
            // InternalMiniOCLCS.g:495:4: rule__CollectExpCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CollectExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleIteratorVarCS"
    // InternalMiniOCLCS.g:504:1: entryRuleIteratorVarCS : ruleIteratorVarCS EOF ;
    public final void entryRuleIteratorVarCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:505:1: ( ruleIteratorVarCS EOF )
            // InternalMiniOCLCS.g:506:1: ruleIteratorVarCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIteratorVarCS();

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

            }

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


    // $ANTLR start "ruleIteratorVarCS"
    // InternalMiniOCLCS.g:513:1: ruleIteratorVarCS : ( ( rule__IteratorVarCS__Group__0 ) ) ;
    public final void ruleIteratorVarCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:517:2: ( ( ( rule__IteratorVarCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:518:2: ( ( rule__IteratorVarCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:518:2: ( ( rule__IteratorVarCS__Group__0 ) )
            // InternalMiniOCLCS.g:519:3: ( rule__IteratorVarCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:520:3: ( rule__IteratorVarCS__Group__0 )
            // InternalMiniOCLCS.g:520:4: rule__IteratorVarCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__IteratorVarCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleIterateExpCS"
    // InternalMiniOCLCS.g:529:1: entryRuleIterateExpCS : ruleIterateExpCS EOF ;
    public final void entryRuleIterateExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:530:1: ( ruleIterateExpCS EOF )
            // InternalMiniOCLCS.g:531:1: ruleIterateExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIterateExpCS();

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

            }

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


    // $ANTLR start "ruleIterateExpCS"
    // InternalMiniOCLCS.g:538:1: ruleIterateExpCS : ( ( rule__IterateExpCS__Group__0 ) ) ;
    public final void ruleIterateExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:542:2: ( ( ( rule__IterateExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:543:2: ( ( rule__IterateExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:543:2: ( ( rule__IterateExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:544:3: ( rule__IterateExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:545:3: ( rule__IterateExpCS__Group__0 )
            // InternalMiniOCLCS.g:545:4: rule__IterateExpCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__IterateExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAccVarCS"
    // InternalMiniOCLCS.g:554:1: entryRuleAccVarCS : ruleAccVarCS EOF ;
    public final void entryRuleAccVarCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:555:1: ( ruleAccVarCS EOF )
            // InternalMiniOCLCS.g:556:1: ruleAccVarCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleAccVarCS();

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

            }

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


    // $ANTLR start "ruleAccVarCS"
    // InternalMiniOCLCS.g:563:1: ruleAccVarCS : ( ( rule__AccVarCS__Group__0 ) ) ;
    public final void ruleAccVarCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:567:2: ( ( ( rule__AccVarCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:568:2: ( ( rule__AccVarCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:568:2: ( ( rule__AccVarCS__Group__0 ) )
            // InternalMiniOCLCS.g:569:3: ( rule__AccVarCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:570:3: ( rule__AccVarCS__Group__0 )
            // InternalMiniOCLCS.g:570:4: rule__AccVarCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleNameExpCS"
    // InternalMiniOCLCS.g:579:1: entryRuleNameExpCS : ruleNameExpCS EOF ;
    public final void entryRuleNameExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:580:1: ( ruleNameExpCS EOF )
            // InternalMiniOCLCS.g:581: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"
    // InternalMiniOCLCS.g:588:1: ruleNameExpCS : ( ( rule__NameExpCS__Group__0 ) ) ;
    public final void ruleNameExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:592:2: ( ( ( rule__NameExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:593:2: ( ( rule__NameExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:593:2: ( ( rule__NameExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:594:3: ( rule__NameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:595:3: ( rule__NameExpCS__Group__0 )
            // InternalMiniOCLCS.g:595: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 "entryRuleRoundedBracketClauseCS"
    // InternalMiniOCLCS.g:604:1: entryRuleRoundedBracketClauseCS : ruleRoundedBracketClauseCS EOF ;
    public final void entryRuleRoundedBracketClauseCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:605:1: ( ruleRoundedBracketClauseCS EOF )
            // InternalMiniOCLCS.g:606:1: ruleRoundedBracketClauseCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleRoundedBracketClauseCS();

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

            }

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


    // $ANTLR start "ruleRoundedBracketClauseCS"
    // InternalMiniOCLCS.g:613:1: ruleRoundedBracketClauseCS : ( ( rule__RoundedBracketClauseCS__Group__0 ) ) ;
    public final void ruleRoundedBracketClauseCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:617:2: ( ( ( rule__RoundedBracketClauseCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:618:2: ( ( rule__RoundedBracketClauseCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:618:2: ( ( rule__RoundedBracketClauseCS__Group__0 ) )
            // InternalMiniOCLCS.g:619:3: ( rule__RoundedBracketClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:620:3: ( rule__RoundedBracketClauseCS__Group__0 )
            // InternalMiniOCLCS.g:620:4: rule__RoundedBracketClauseCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLiteralExpCS"
    // InternalMiniOCLCS.g:629:1: entryRuleLiteralExpCS : ruleLiteralExpCS EOF ;
    public final void entryRuleLiteralExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:630:1: ( ruleLiteralExpCS EOF )
            // InternalMiniOCLCS.g:631:1: ruleLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLiteralExpCS();

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

            }

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


    // $ANTLR start "ruleLiteralExpCS"
    // InternalMiniOCLCS.g:638:1: ruleLiteralExpCS : ( ( rule__LiteralExpCS__Alternatives ) ) ;
    public final void ruleLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:642:2: ( ( ( rule__LiteralExpCS__Alternatives ) ) )
            // InternalMiniOCLCS.g:643:2: ( ( rule__LiteralExpCS__Alternatives ) )
            {
            // InternalMiniOCLCS.g:643:2: ( ( rule__LiteralExpCS__Alternatives ) )
            // InternalMiniOCLCS.g:644:3: ( rule__LiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLiteralExpCSAccess().getAlternatives()); 
            }
            // InternalMiniOCLCS.g:645:3: ( rule__LiteralExpCS__Alternatives )
            // InternalMiniOCLCS.g:645:4: rule__LiteralExpCS__Alternatives
            {
            pushFollow(FOLLOW_2);
            rule__LiteralExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleIntLiteralExpCS"
    // InternalMiniOCLCS.g:654:1: entryRuleIntLiteralExpCS : ruleIntLiteralExpCS EOF ;
    public final void entryRuleIntLiteralExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:655:1: ( ruleIntLiteralExpCS EOF )
            // InternalMiniOCLCS.g:656:1: ruleIntLiteralExpCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIntLiteralExpCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIntLiteralExpCS();

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

            }

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


    // $ANTLR start "ruleIntLiteralExpCS"
    // InternalMiniOCLCS.g:663:1: ruleIntLiteralExpCS : ( ( rule__IntLiteralExpCS__IntSymbolAssignment ) ) ;
    public final void ruleIntLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:667:2: ( ( ( rule__IntLiteralExpCS__IntSymbolAssignment ) ) )
            // InternalMiniOCLCS.g:668:2: ( ( rule__IntLiteralExpCS__IntSymbolAssignment ) )
            {
            // InternalMiniOCLCS.g:668:2: ( ( rule__IntLiteralExpCS__IntSymbolAssignment ) )
            // InternalMiniOCLCS.g:669:3: ( rule__IntLiteralExpCS__IntSymbolAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIntLiteralExpCSAccess().getIntSymbolAssignment()); 
            }
            // InternalMiniOCLCS.g:670:3: ( rule__IntLiteralExpCS__IntSymbolAssignment )
            // InternalMiniOCLCS.g:670:4: rule__IntLiteralExpCS__IntSymbolAssignment
            {
            pushFollow(FOLLOW_2);
            rule__IntLiteralExpCS__IntSymbolAssignment();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIntLiteralExpCSAccess().getIntSymbolAssignment()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleBooleanLiteralExpCS"
    // InternalMiniOCLCS.g:679:1: entryRuleBooleanLiteralExpCS : ruleBooleanLiteralExpCS EOF ;
    public final void entryRuleBooleanLiteralExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:680:1: ( ruleBooleanLiteralExpCS EOF )
            // InternalMiniOCLCS.g:681: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"
    // InternalMiniOCLCS.g:688:1: ruleBooleanLiteralExpCS : ( ( rule__BooleanLiteralExpCS__Group__0 ) ) ;
    public final void ruleBooleanLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:692:2: ( ( ( rule__BooleanLiteralExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:693:2: ( ( rule__BooleanLiteralExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:693:2: ( ( rule__BooleanLiteralExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:694:3: ( rule__BooleanLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:695:3: ( rule__BooleanLiteralExpCS__Group__0 )
            // InternalMiniOCLCS.g:695:4: rule__BooleanLiteralExpCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__BooleanLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleNullLiteralExpCS"
    // InternalMiniOCLCS.g:704:1: entryRuleNullLiteralExpCS : ruleNullLiteralExpCS EOF ;
    public final void entryRuleNullLiteralExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:705:1: ( ruleNullLiteralExpCS EOF )
            // InternalMiniOCLCS.g:706: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"
    // InternalMiniOCLCS.g:713:1: ruleNullLiteralExpCS : ( ( rule__NullLiteralExpCS__Group__0 ) ) ;
    public final void ruleNullLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:717:2: ( ( ( rule__NullLiteralExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:718:2: ( ( rule__NullLiteralExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:718:2: ( ( rule__NullLiteralExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:719:3: ( rule__NullLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:720:3: ( rule__NullLiteralExpCS__Group__0 )
            // InternalMiniOCLCS.g:720: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 "entryRuleCollectionLiteralExpCS"
    // InternalMiniOCLCS.g:729:1: entryRuleCollectionLiteralExpCS : ruleCollectionLiteralExpCS EOF ;
    public final void entryRuleCollectionLiteralExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:730:1: ( ruleCollectionLiteralExpCS EOF )
            // InternalMiniOCLCS.g:731: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"
    // InternalMiniOCLCS.g:738:1: ruleCollectionLiteralExpCS : ( ( rule__CollectionLiteralExpCS__Group__0 ) ) ;
    public final void ruleCollectionLiteralExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:742:2: ( ( ( rule__CollectionLiteralExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:743:2: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:743:2: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:744:3: ( rule__CollectionLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:745:3: ( rule__CollectionLiteralExpCS__Group__0 )
            // InternalMiniOCLCS.g:745: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"
    // InternalMiniOCLCS.g:754:1: entryRuleCollectionLiteralPartCS : ruleCollectionLiteralPartCS EOF ;
    public final void entryRuleCollectionLiteralPartCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:755:1: ( ruleCollectionLiteralPartCS EOF )
            // InternalMiniOCLCS.g:756: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"
    // InternalMiniOCLCS.g:763:1: ruleCollectionLiteralPartCS : ( ( rule__CollectionLiteralPartCS__Group__0 ) ) ;
    public final void ruleCollectionLiteralPartCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:767:2: ( ( ( rule__CollectionLiteralPartCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:768:2: ( ( rule__CollectionLiteralPartCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:768:2: ( ( rule__CollectionLiteralPartCS__Group__0 ) )
            // InternalMiniOCLCS.g:769:3: ( rule__CollectionLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:770:3: ( rule__CollectionLiteralPartCS__Group__0 )
            // InternalMiniOCLCS.g:770:4: rule__CollectionLiteralPartCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleLetExpCS"
    // InternalMiniOCLCS.g:779:1: entryRuleLetExpCS : ruleLetExpCS EOF ;
    public final void entryRuleLetExpCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:780:1: ( ruleLetExpCS EOF )
            // InternalMiniOCLCS.g:781: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"
    // InternalMiniOCLCS.g:788:1: ruleLetExpCS : ( ( rule__LetExpCS__Group__0 ) ) ;
    public final void ruleLetExpCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:792:2: ( ( ( rule__LetExpCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:793:2: ( ( rule__LetExpCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:793:2: ( ( rule__LetExpCS__Group__0 ) )
            // InternalMiniOCLCS.g:794:3: ( rule__LetExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:795:3: ( rule__LetExpCS__Group__0 )
            // InternalMiniOCLCS.g:795: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 "entryRuleLetVarCS"
    // InternalMiniOCLCS.g:804:1: entryRuleLetVarCS : ruleLetVarCS EOF ;
    public final void entryRuleLetVarCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:805:1: ( ruleLetVarCS EOF )
            // InternalMiniOCLCS.g:806:1: ruleLetVarCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleLetVarCS();

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

            }

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


    // $ANTLR start "ruleLetVarCS"
    // InternalMiniOCLCS.g:813:1: ruleLetVarCS : ( ( rule__LetVarCS__Group__0 ) ) ;
    public final void ruleLetVarCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:817:2: ( ( ( rule__LetVarCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:818:2: ( ( rule__LetVarCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:818:2: ( ( rule__LetVarCS__Group__0 ) )
            // InternalMiniOCLCS.g:819:3: ( rule__LetVarCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:820:3: ( rule__LetVarCS__Group__0 )
            // InternalMiniOCLCS.g:820:4: rule__LetVarCS__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRulePathNameCS"
    // InternalMiniOCLCS.g:829:1: entryRulePathNameCS : rulePathNameCS EOF ;
    public final void entryRulePathNameCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:830:1: ( rulePathNameCS EOF )
            // InternalMiniOCLCS.g:831: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"
    // InternalMiniOCLCS.g:838:1: rulePathNameCS : ( ( rule__PathNameCS__Group__0 ) ) ;
    public final void rulePathNameCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:842:2: ( ( ( rule__PathNameCS__Group__0 ) ) )
            // InternalMiniOCLCS.g:843:2: ( ( rule__PathNameCS__Group__0 ) )
            {
            // InternalMiniOCLCS.g:843:2: ( ( rule__PathNameCS__Group__0 ) )
            // InternalMiniOCLCS.g:844:3: ( rule__PathNameCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup()); 
            }
            // InternalMiniOCLCS.g:845:3: ( rule__PathNameCS__Group__0 )
            // InternalMiniOCLCS.g:845: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 "entryRulePathElementCS"
    // InternalMiniOCLCS.g:854:1: entryRulePathElementCS : rulePathElementCS EOF ;
    public final void entryRulePathElementCS() throws RecognitionException {
        try {
            // InternalMiniOCLCS.g:855:1: ( rulePathElementCS EOF )
            // InternalMiniOCLCS.g:856:1: rulePathElementCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathElementCSRule()); 
            }
            pushFollow(FOLLOW_1);
            rulePathElementCS();

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

            }

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


    // $ANTLR start "rulePathElementCS"
    // InternalMiniOCLCS.g:863:1: rulePathElementCS : ( ( rule__PathElementCS__ElementNameAssignment ) ) ;
    public final void rulePathElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:867:2: ( ( ( rule__PathElementCS__ElementNameAssignment ) ) )
            // InternalMiniOCLCS.g:868:2: ( ( rule__PathElementCS__ElementNameAssignment ) )
            {
            // InternalMiniOCLCS.g:868:2: ( ( rule__PathElementCS__ElementNameAssignment ) )
            // InternalMiniOCLCS.g:869:3: ( rule__PathElementCS__ElementNameAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathElementCSAccess().getElementNameAssignment()); 
            }
            // InternalMiniOCLCS.g:870:3: ( rule__PathElementCS__ElementNameAssignment )
            // InternalMiniOCLCS.g:870:4: rule__PathElementCS__ElementNameAssignment
            {
            pushFollow(FOLLOW_2);
            rule__PathElementCS__ElementNameAssignment();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathElementCSAccess().getElementNameAssignment()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "ruleCollectionKindCS"
    // InternalMiniOCLCS.g:879:1: ruleCollectionKindCS : ( ( 'Collection' ) ) ;
    public final void ruleCollectionKindCS() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:883:1: ( ( ( 'Collection' ) ) )
            // InternalMiniOCLCS.g:884:2: ( ( 'Collection' ) )
            {
            // InternalMiniOCLCS.g:884:2: ( ( 'Collection' ) )
            // InternalMiniOCLCS.g:885:3: ( 'Collection' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionKindCSAccess().getCollectionEnumLiteralDeclaration()); 
            }
            // InternalMiniOCLCS.g:886:3: ( 'Collection' )
            // InternalMiniOCLCS.g:886:4: 'Collection'
            {
            match(input,11,FOLLOW_2); if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionKindCSAccess().getCollectionEnumLiteralDeclaration()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RootCS__Alternatives_1"
    // InternalMiniOCLCS.g:894:1: rule__RootCS__Alternatives_1 : ( ( ( rule__RootCS__PackagesAssignment_1_0 ) ) | ( ( rule__RootCS__ConstraintsAssignment_1_1 ) ) );
    public final void rule__RootCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:898:1: ( ( ( rule__RootCS__PackagesAssignment_1_0 ) ) | ( ( rule__RootCS__ConstraintsAssignment_1_1 ) ) )
            int alt1=2;
            int LA1_0 = input.LA(1);

            if ( (LA1_0==20) ) {
                alt1=1;
            }
            else if ( (LA1_0==33) ) {
                alt1=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 1, 0, input);

                throw nvae;
            }
            switch (alt1) {
                case 1 :
                    // InternalMiniOCLCS.g:899:2: ( ( rule__RootCS__PackagesAssignment_1_0 ) )
                    {
                    // InternalMiniOCLCS.g:899:2: ( ( rule__RootCS__PackagesAssignment_1_0 ) )
                    // InternalMiniOCLCS.g:900:3: ( rule__RootCS__PackagesAssignment_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRootCSAccess().getPackagesAssignment_1_0()); 
                    }
                    // InternalMiniOCLCS.g:901:3: ( rule__RootCS__PackagesAssignment_1_0 )
                    // InternalMiniOCLCS.g:901:4: rule__RootCS__PackagesAssignment_1_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__RootCS__PackagesAssignment_1_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRootCSAccess().getPackagesAssignment_1_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:905:2: ( ( rule__RootCS__ConstraintsAssignment_1_1 ) )
                    {
                    // InternalMiniOCLCS.g:905:2: ( ( rule__RootCS__ConstraintsAssignment_1_1 ) )
                    // InternalMiniOCLCS.g:906:3: ( rule__RootCS__ConstraintsAssignment_1_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRootCSAccess().getConstraintsAssignment_1_1()); 
                    }
                    // InternalMiniOCLCS.g:907:3: ( rule__RootCS__ConstraintsAssignment_1_1 )
                    // InternalMiniOCLCS.g:907:4: rule__RootCS__ConstraintsAssignment_1_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__RootCS__ConstraintsAssignment_1_1();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRootCSAccess().getConstraintsAssignment_1_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Alternatives_3"
    // InternalMiniOCLCS.g:915:1: rule__PackageCS__Alternatives_3 : ( ( ( rule__PackageCS__PackagesAssignment_3_0 ) ) | ( ( rule__PackageCS__ClassesAssignment_3_1 ) ) );
    public final void rule__PackageCS__Alternatives_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:919:1: ( ( ( rule__PackageCS__PackagesAssignment_3_0 ) ) | ( ( rule__PackageCS__ClassesAssignment_3_1 ) ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // InternalMiniOCLCS.g:920:2: ( ( rule__PackageCS__PackagesAssignment_3_0 ) )
                    {
                    // InternalMiniOCLCS.g:920:2: ( ( rule__PackageCS__PackagesAssignment_3_0 ) )
                    // InternalMiniOCLCS.g:921:3: ( rule__PackageCS__PackagesAssignment_3_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPackageCSAccess().getPackagesAssignment_3_0()); 
                    }
                    // InternalMiniOCLCS.g:922:3: ( rule__PackageCS__PackagesAssignment_3_0 )
                    // InternalMiniOCLCS.g:922:4: rule__PackageCS__PackagesAssignment_3_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__PackageCS__PackagesAssignment_3_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPackageCSAccess().getPackagesAssignment_3_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:926:2: ( ( rule__PackageCS__ClassesAssignment_3_1 ) )
                    {
                    // InternalMiniOCLCS.g:926:2: ( ( rule__PackageCS__ClassesAssignment_3_1 ) )
                    // InternalMiniOCLCS.g:927:3: ( rule__PackageCS__ClassesAssignment_3_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPackageCSAccess().getClassesAssignment_3_1()); 
                    }
                    // InternalMiniOCLCS.g:928:3: ( rule__PackageCS__ClassesAssignment_3_1 )
                    // InternalMiniOCLCS.g:928:4: rule__PackageCS__ClassesAssignment_3_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__PackageCS__ClassesAssignment_3_1();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPackageCSAccess().getClassesAssignment_3_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Alternatives_4"
    // InternalMiniOCLCS.g:936:1: rule__ClassCS__Alternatives_4 : ( ( ( rule__ClassCS__PropertiesAssignment_4_0 ) ) | ( ( rule__ClassCS__OperationsAssignment_4_1 ) ) );
    public final void rule__ClassCS__Alternatives_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:940:1: ( ( ( rule__ClassCS__PropertiesAssignment_4_0 ) ) | ( ( rule__ClassCS__OperationsAssignment_4_1 ) ) )
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==25) ) {
                alt3=1;
            }
            else if ( (LA3_0==29) ) {
                alt3=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }
            switch (alt3) {
                case 1 :
                    // InternalMiniOCLCS.g:941:2: ( ( rule__ClassCS__PropertiesAssignment_4_0 ) )
                    {
                    // InternalMiniOCLCS.g:941:2: ( ( rule__ClassCS__PropertiesAssignment_4_0 ) )
                    // InternalMiniOCLCS.g:942:3: ( rule__ClassCS__PropertiesAssignment_4_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getClassCSAccess().getPropertiesAssignment_4_0()); 
                    }
                    // InternalMiniOCLCS.g:943:3: ( rule__ClassCS__PropertiesAssignment_4_0 )
                    // InternalMiniOCLCS.g:943:4: rule__ClassCS__PropertiesAssignment_4_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassCS__PropertiesAssignment_4_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getClassCSAccess().getPropertiesAssignment_4_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:947:2: ( ( rule__ClassCS__OperationsAssignment_4_1 ) )
                    {
                    // InternalMiniOCLCS.g:947:2: ( ( rule__ClassCS__OperationsAssignment_4_1 ) )
                    // InternalMiniOCLCS.g:948:3: ( rule__ClassCS__OperationsAssignment_4_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getClassCSAccess().getOperationsAssignment_4_1()); 
                    }
                    // InternalMiniOCLCS.g:949:3: ( rule__ClassCS__OperationsAssignment_4_1 )
                    // InternalMiniOCLCS.g:949:4: rule__ClassCS__OperationsAssignment_4_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassCS__OperationsAssignment_4_1();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getClassCSAccess().getOperationsAssignment_4_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Alternatives_1"
    // InternalMiniOCLCS.g:957:1: rule__MultiplicityCS__Alternatives_1 : ( ( ( rule__MultiplicityCS__OptAssignment_1_0 ) ) | ( ( rule__MultiplicityCS__MultAssignment_1_1 ) ) | ( ( rule__MultiplicityCS__MandatoryAssignment_1_2 ) ) | ( ( rule__MultiplicityCS__Group_1_3__0 ) ) );
    public final void rule__MultiplicityCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:961:1: ( ( ( rule__MultiplicityCS__OptAssignment_1_0 ) ) | ( ( rule__MultiplicityCS__MultAssignment_1_1 ) ) | ( ( rule__MultiplicityCS__MandatoryAssignment_1_2 ) ) | ( ( rule__MultiplicityCS__Group_1_3__0 ) ) )
            int alt4=4;
            switch ( input.LA(1) ) {
            case 43:
                {
                alt4=1;
                }
                break;
            case 44:
                {
                alt4=2;
                }
                break;
            case RULE_INT:
                {
                int LA4_3 = input.LA(2);

                if ( (LA4_3==27) ) {
                    alt4=3;
                }
                else if ( (LA4_3==28) ) {
                    alt4=4;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 4, 3, input);

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

                throw nvae;
            }

            switch (alt4) {
                case 1 :
                    // InternalMiniOCLCS.g:962:2: ( ( rule__MultiplicityCS__OptAssignment_1_0 ) )
                    {
                    // InternalMiniOCLCS.g:962:2: ( ( rule__MultiplicityCS__OptAssignment_1_0 ) )
                    // InternalMiniOCLCS.g:963:3: ( rule__MultiplicityCS__OptAssignment_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getOptAssignment_1_0()); 
                    }
                    // InternalMiniOCLCS.g:964:3: ( rule__MultiplicityCS__OptAssignment_1_0 )
                    // InternalMiniOCLCS.g:964:4: rule__MultiplicityCS__OptAssignment_1_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__OptAssignment_1_0();

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

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:968:2: ( ( rule__MultiplicityCS__MultAssignment_1_1 ) )
                    {
                    // InternalMiniOCLCS.g:968:2: ( ( rule__MultiplicityCS__MultAssignment_1_1 ) )
                    // InternalMiniOCLCS.g:969:3: ( rule__MultiplicityCS__MultAssignment_1_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultAssignment_1_1()); 
                    }
                    // InternalMiniOCLCS.g:970:3: ( rule__MultiplicityCS__MultAssignment_1_1 )
                    // InternalMiniOCLCS.g:970:4: rule__MultiplicityCS__MultAssignment_1_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__MultAssignment_1_1();

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

                    }

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

                    }


                    }
                    break;
                case 3 :
                    // InternalMiniOCLCS.g:974:2: ( ( rule__MultiplicityCS__MandatoryAssignment_1_2 ) )
                    {
                    // InternalMiniOCLCS.g:974:2: ( ( rule__MultiplicityCS__MandatoryAssignment_1_2 ) )
                    // InternalMiniOCLCS.g:975:3: ( rule__MultiplicityCS__MandatoryAssignment_1_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMandatoryAssignment_1_2()); 
                    }
                    // InternalMiniOCLCS.g:976:3: ( rule__MultiplicityCS__MandatoryAssignment_1_2 )
                    // InternalMiniOCLCS.g:976:4: rule__MultiplicityCS__MandatoryAssignment_1_2
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__MandatoryAssignment_1_2();

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

                    }

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

                    }


                    }
                    break;
                case 4 :
                    // InternalMiniOCLCS.g:980:2: ( ( rule__MultiplicityCS__Group_1_3__0 ) )
                    {
                    // InternalMiniOCLCS.g:980:2: ( ( rule__MultiplicityCS__Group_1_3__0 ) )
                    // InternalMiniOCLCS.g:981:3: ( rule__MultiplicityCS__Group_1_3__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getGroup_1_3()); 
                    }
                    // InternalMiniOCLCS.g:982:3: ( rule__MultiplicityCS__Group_1_3__0 )
                    // InternalMiniOCLCS.g:982:4: rule__MultiplicityCS__Group_1_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__Group_1_3__0();

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

                    }

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Alternatives_1_3_2"
    // InternalMiniOCLCS.g:990:1: rule__MultiplicityCS__Alternatives_1_3_2 : ( ( ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 ) ) | ( ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 ) ) );
    public final void rule__MultiplicityCS__Alternatives_1_3_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:994:1: ( ( ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 ) ) | ( ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 ) ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

            if ( (LA5_0==RULE_INT) ) {
                alt5=1;
            }
            else if ( (LA5_0==44) ) {
                alt5=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 5, 0, input);

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // InternalMiniOCLCS.g:995:2: ( ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 ) )
                    {
                    // InternalMiniOCLCS.g:995:2: ( ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 ) )
                    // InternalMiniOCLCS.g:996:3: ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getUpperIntAssignment_1_3_2_0()); 
                    }
                    // InternalMiniOCLCS.g:997:3: ( rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 )
                    // InternalMiniOCLCS.g:997:4: rule__MultiplicityCS__UpperIntAssignment_1_3_2_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__UpperIntAssignment_1_3_2_0();

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

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1001:2: ( ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 ) )
                    {
                    // InternalMiniOCLCS.g:1001:2: ( ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 ) )
                    // InternalMiniOCLCS.g:1002:3: ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getUpperMultAssignment_1_3_2_1()); 
                    }
                    // InternalMiniOCLCS.g:1003:3: ( rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 )
                    // InternalMiniOCLCS.g:1003:4: rule__MultiplicityCS__UpperMultAssignment_1_3_2_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__MultiplicityCS__UpperMultAssignment_1_3_2_1();

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

                    }

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__OpNameAlternatives_1_1_0"
    // InternalMiniOCLCS.g:1011:1: rule__EqualityExpCS__OpNameAlternatives_1_1_0 : ( ( '=' ) | ( '<>' ) );
    public final void rule__EqualityExpCS__OpNameAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1015:1: ( ( '=' ) | ( '<>' ) )
            int alt6=2;
            int LA6_0 = input.LA(1);

            if ( (LA6_0==12) ) {
                alt6=1;
            }
            else if ( (LA6_0==13) ) {
                alt6=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 6, 0, input);

                throw nvae;
            }
            switch (alt6) {
                case 1 :
                    // InternalMiniOCLCS.g:1016:2: ( '=' )
                    {
                    // InternalMiniOCLCS.g:1016:2: ( '=' )
                    // InternalMiniOCLCS.g:1017:3: '='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEqualityExpCSAccess().getOpNameEqualsSignKeyword_1_1_0_0()); 
                    }
                    match(input,12,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEqualityExpCSAccess().getOpNameEqualsSignKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1022:2: ( '<>' )
                    {
                    // InternalMiniOCLCS.g:1022:2: ( '<>' )
                    // InternalMiniOCLCS.g:1023:3: '<>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEqualityExpCSAccess().getOpNameLessThanSignGreaterThanSignKeyword_1_1_0_1()); 
                    }
                    match(input,13,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEqualityExpCSAccess().getOpNameLessThanSignGreaterThanSignKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__OpNameAlternatives_1_1_0"
    // InternalMiniOCLCS.g:1032:1: rule__CallExpCS__OpNameAlternatives_1_1_0 : ( ( '.' ) | ( '->' ) );
    public final void rule__CallExpCS__OpNameAlternatives_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1036:1: ( ( '.' ) | ( '->' ) )
            int alt7=2;
            int LA7_0 = input.LA(1);

            if ( (LA7_0==14) ) {
                alt7=1;
            }
            else if ( (LA7_0==15) ) {
                alt7=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 7, 0, input);

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // InternalMiniOCLCS.g:1037:2: ( '.' )
                    {
                    // InternalMiniOCLCS.g:1037:2: ( '.' )
                    // InternalMiniOCLCS.g:1038:3: '.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCallExpCSAccess().getOpNameFullStopKeyword_1_1_0_0()); 
                    }
                    match(input,14,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCallExpCSAccess().getOpNameFullStopKeyword_1_1_0_0()); 
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1043:2: ( '->' )
                    {
                    // InternalMiniOCLCS.g:1043:2: ( '->' )
                    // InternalMiniOCLCS.g:1044:3: '->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCallExpCSAccess().getOpNameHyphenMinusGreaterThanSignKeyword_1_1_0_1()); 
                    }
                    match(input,15,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCallExpCSAccess().getOpNameHyphenMinusGreaterThanSignKeyword_1_1_0_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PrimaryExpCS__Alternatives"
    // InternalMiniOCLCS.g:1053:1: rule__PrimaryExpCS__Alternatives : ( ( ruleSelfExpCS ) | ( ruleNameExpCS ) | ( ruleLiteralExpCS ) | ( ruleLetExpCS ) );
    public final void rule__PrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1057:1: ( ( ruleSelfExpCS ) | ( ruleNameExpCS ) | ( ruleLiteralExpCS ) | ( ruleLetExpCS ) )
            int alt8=4;
            switch ( input.LA(1) ) {
            case 35:
                {
                alt8=1;
                }
                break;
            case RULE_ID:
                {
                alt8=2;
                }
                break;
            case RULE_INT:
            case 11:
            case 16:
            case 39:
            case 45:
                {
                alt8=3;
                }
                break;
            case 40:
                {
                alt8=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }

            switch (alt8) {
                case 1 :
                    // InternalMiniOCLCS.g:1058:2: ( ruleSelfExpCS )
                    {
                    // InternalMiniOCLCS.g:1058:2: ( ruleSelfExpCS )
                    // InternalMiniOCLCS.g:1059:3: ruleSelfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleSelfExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1064:2: ( ruleNameExpCS )
                    {
                    // InternalMiniOCLCS.g:1064:2: ( ruleNameExpCS )
                    // InternalMiniOCLCS.g:1065:3: ruleNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleNameExpCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalMiniOCLCS.g:1070:2: ( ruleLiteralExpCS )
                    {
                    // InternalMiniOCLCS.g:1070:2: ( ruleLiteralExpCS )
                    // InternalMiniOCLCS.g:1071:3: ruleLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getLiteralExpCSParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleLiteralExpCS();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalMiniOCLCS.g:1076:2: ( ruleLetExpCS )
                    {
                    // InternalMiniOCLCS.g:1076:2: ( ruleLetExpCS )
                    // InternalMiniOCLCS.g:1077:3: ruleLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getLetExpCSParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleLetExpCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NavigationExpCS__Alternatives"
    // InternalMiniOCLCS.g:1086:1: rule__NavigationExpCS__Alternatives : ( ( ruleLoopExpCS ) | ( ruleNameExpCS ) );
    public final void rule__NavigationExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1090:1: ( ( ruleLoopExpCS ) | ( ruleNameExpCS ) )
            int alt9=2;
            int LA9_0 = input.LA(1);

            if ( (LA9_0==36||LA9_0==38) ) {
                alt9=1;
            }
            else if ( (LA9_0==RULE_ID) ) {
                alt9=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 9, 0, input);

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // InternalMiniOCLCS.g:1091:2: ( ruleLoopExpCS )
                    {
                    // InternalMiniOCLCS.g:1091:2: ( ruleLoopExpCS )
                    // InternalMiniOCLCS.g:1092:3: ruleLoopExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigationExpCSAccess().getLoopExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleLoopExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1097:2: ( ruleNameExpCS )
                    {
                    // InternalMiniOCLCS.g:1097:2: ( ruleNameExpCS )
                    // InternalMiniOCLCS.g:1098:3: ruleNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigationExpCSAccess().getNameExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleNameExpCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LoopExpCS__Alternatives"
    // InternalMiniOCLCS.g:1107:1: rule__LoopExpCS__Alternatives : ( ( ruleCollectExpCS ) | ( ruleIterateExpCS ) );
    public final void rule__LoopExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1111:1: ( ( ruleCollectExpCS ) | ( ruleIterateExpCS ) )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==36) ) {
                alt10=1;
            }
            else if ( (LA10_0==38) ) {
                alt10=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // InternalMiniOCLCS.g:1112:2: ( ruleCollectExpCS )
                    {
                    // InternalMiniOCLCS.g:1112:2: ( ruleCollectExpCS )
                    // InternalMiniOCLCS.g:1113:3: ruleCollectExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLoopExpCSAccess().getCollectExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1118:2: ( ruleIterateExpCS )
                    {
                    // InternalMiniOCLCS.g:1118:2: ( ruleIterateExpCS )
                    // InternalMiniOCLCS.g:1119:3: ruleIterateExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLoopExpCSAccess().getIterateExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleIterateExpCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__LiteralExpCS__Alternatives"
    // InternalMiniOCLCS.g:1128:1: rule__LiteralExpCS__Alternatives : ( ( ruleIntLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleNullLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) );
    public final void rule__LiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1132:1: ( ( ruleIntLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleNullLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) )
            int alt11=4;
            switch ( input.LA(1) ) {
            case RULE_INT:
                {
                alt11=1;
                }
                break;
            case 16:
            case 45:
                {
                alt11=2;
                }
                break;
            case 39:
                {
                alt11=3;
                }
                break;
            case 11:
                {
                alt11=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }

            switch (alt11) {
                case 1 :
                    // InternalMiniOCLCS.g:1133:2: ( ruleIntLiteralExpCS )
                    {
                    // InternalMiniOCLCS.g:1133:2: ( ruleIntLiteralExpCS )
                    // InternalMiniOCLCS.g:1134:3: ruleIntLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralExpCSAccess().getIntLiteralExpCSParserRuleCall_0()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleIntLiteralExpCS();

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1139:2: ( ruleBooleanLiteralExpCS )
                    {
                    // InternalMiniOCLCS.g:1139:2: ( ruleBooleanLiteralExpCS )
                    // InternalMiniOCLCS.g:1140:3: ruleBooleanLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_1()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleBooleanLiteralExpCS();

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

                    }


                    }
                    break;
                case 3 :
                    // InternalMiniOCLCS.g:1145:2: ( ruleNullLiteralExpCS )
                    {
                    // InternalMiniOCLCS.g:1145:2: ( ruleNullLiteralExpCS )
                    // InternalMiniOCLCS.g:1146:3: ruleNullLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_2()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleNullLiteralExpCS();

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

                    }


                    }
                    break;
                case 4 :
                    // InternalMiniOCLCS.g:1151:2: ( ruleCollectionLiteralExpCS )
                    {
                    // InternalMiniOCLCS.g:1151:2: ( ruleCollectionLiteralExpCS )
                    // InternalMiniOCLCS.g:1152:3: ruleCollectionLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getLiteralExpCSAccess().getCollectionLiteralExpCSParserRuleCall_3()); 
                    }
                    pushFollow(FOLLOW_2);
                    ruleCollectionLiteralExpCS();

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

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__BooleanLiteralExpCS__Alternatives_1"
    // InternalMiniOCLCS.g:1161:1: rule__BooleanLiteralExpCS__Alternatives_1 : ( ( ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 ) ) | ( 'false' ) );
    public final void rule__BooleanLiteralExpCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1165:1: ( ( ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 ) ) | ( 'false' ) )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==45) ) {
                alt12=1;
            }
            else if ( (LA12_0==16) ) {
                alt12=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // InternalMiniOCLCS.g:1166:2: ( ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 ) )
                    {
                    // InternalMiniOCLCS.g:1166:2: ( ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 ) )
                    // InternalMiniOCLCS.g:1167:3: ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getBoolSymbolAssignment_1_0()); 
                    }
                    // InternalMiniOCLCS.g:1168:3: ( rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 )
                    // InternalMiniOCLCS.g:1168:4: rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0
                    {
                    pushFollow(FOLLOW_2);
                    rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0();

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

                    }

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

                    }


                    }
                    break;
                case 2 :
                    // InternalMiniOCLCS.g:1172:2: ( 'false' )
                    {
                    // InternalMiniOCLCS.g:1172:2: ( 'false' )
                    // InternalMiniOCLCS.g:1173:3: 'false'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getFalseKeyword_1_1()); 
                    }
                    match(input,16,FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBooleanLiteralExpCSAccess().getFalseKeyword_1_1()); 
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RootCS__Group__0"
    // InternalMiniOCLCS.g:1182:1: rule__RootCS__Group__0 : rule__RootCS__Group__0__Impl rule__RootCS__Group__1 ;
    public final void rule__RootCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1186:1: ( rule__RootCS__Group__0__Impl rule__RootCS__Group__1 )
            // InternalMiniOCLCS.g:1187:2: rule__RootCS__Group__0__Impl rule__RootCS__Group__1
            {
            pushFollow(FOLLOW_3);
            rule__RootCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RootCS__Group__0__Impl"
    // InternalMiniOCLCS.g:1194:1: rule__RootCS__Group__0__Impl : ( ( rule__RootCS__ImportsAssignment_0 )* ) ;
    public final void rule__RootCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1198:1: ( ( ( rule__RootCS__ImportsAssignment_0 )* ) )
            // InternalMiniOCLCS.g:1199:1: ( ( rule__RootCS__ImportsAssignment_0 )* )
            {
            // InternalMiniOCLCS.g:1199:1: ( ( rule__RootCS__ImportsAssignment_0 )* )
            // InternalMiniOCLCS.g:1200:2: ( rule__RootCS__ImportsAssignment_0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRootCSAccess().getImportsAssignment_0()); 
            }
            // InternalMiniOCLCS.g:1201:2: ( rule__RootCS__ImportsAssignment_0 )*
            loop13:
            do {
                int alt13=2;
                int LA13_0 = input.LA(1);

                if ( (LA13_0==17) ) {
                    alt13=1;
                }


                switch (alt13) {
            	case 1 :
            	    // InternalMiniOCLCS.g:1201:3: rule__RootCS__ImportsAssignment_0
            	    {
            	    pushFollow(FOLLOW_4);
            	    rule__RootCS__ImportsAssignment_0();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRootCSAccess().getImportsAssignment_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RootCS__Group__1"
    // InternalMiniOCLCS.g:1209:1: rule__RootCS__Group__1 : rule__RootCS__Group__1__Impl ;
    public final void rule__RootCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1213:1: ( rule__RootCS__Group__1__Impl )
            // InternalMiniOCLCS.g:1214:2: rule__RootCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RootCS__Group__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RootCS__Group__1__Impl"
    // InternalMiniOCLCS.g:1220:1: rule__RootCS__Group__1__Impl : ( ( rule__RootCS__Alternatives_1 )* ) ;
    public final void rule__RootCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1224:1: ( ( ( rule__RootCS__Alternatives_1 )* ) )
            // InternalMiniOCLCS.g:1225:1: ( ( rule__RootCS__Alternatives_1 )* )
            {
            // InternalMiniOCLCS.g:1225:1: ( ( rule__RootCS__Alternatives_1 )* )
            // InternalMiniOCLCS.g:1226:2: ( rule__RootCS__Alternatives_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRootCSAccess().getAlternatives_1()); 
            }
            // InternalMiniOCLCS.g:1227:2: ( rule__RootCS__Alternatives_1 )*
            loop14:
            do {
                int alt14=2;
                int LA14_0 = input.LA(1);

                if ( (LA14_0==20||LA14_0==33) ) {
                    alt14=1;
                }


                switch (alt14) {
            	case 1 :
            	    // InternalMiniOCLCS.g:1227:3: rule__RootCS__Alternatives_1
            	    {
            	    pushFollow(FOLLOW_5);
            	    rule__RootCS__Alternatives_1();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRootCSAccess().getAlternatives_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__0"
    // InternalMiniOCLCS.g:1236:1: rule__ImportCS__Group__0 : rule__ImportCS__Group__0__Impl rule__ImportCS__Group__1 ;
    public final void rule__ImportCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1240:1: ( rule__ImportCS__Group__0__Impl rule__ImportCS__Group__1 )
            // InternalMiniOCLCS.g:1241:2: rule__ImportCS__Group__0__Impl rule__ImportCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ImportCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__0__Impl"
    // InternalMiniOCLCS.g:1248:1: rule__ImportCS__Group__0__Impl : ( 'import' ) ;
    public final void rule__ImportCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1252:1: ( ( 'import' ) )
            // InternalMiniOCLCS.g:1253:1: ( 'import' )
            {
            // InternalMiniOCLCS.g:1253:1: ( 'import' )
            // InternalMiniOCLCS.g:1254:2: 'import'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getImportKeyword_0()); 
            }
            match(input,17,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getImportKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__1"
    // InternalMiniOCLCS.g:1263:1: rule__ImportCS__Group__1 : rule__ImportCS__Group__1__Impl rule__ImportCS__Group__2 ;
    public final void rule__ImportCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1267:1: ( rule__ImportCS__Group__1__Impl rule__ImportCS__Group__2 )
            // InternalMiniOCLCS.g:1268:2: rule__ImportCS__Group__1__Impl rule__ImportCS__Group__2
            {
            pushFollow(FOLLOW_7);
            rule__ImportCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__1__Impl"
    // InternalMiniOCLCS.g:1275:1: rule__ImportCS__Group__1__Impl : ( ( rule__ImportCS__Group_1__0 ) ) ;
    public final void rule__ImportCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1279:1: ( ( ( rule__ImportCS__Group_1__0 ) ) )
            // InternalMiniOCLCS.g:1280:1: ( ( rule__ImportCS__Group_1__0 ) )
            {
            // InternalMiniOCLCS.g:1280:1: ( ( rule__ImportCS__Group_1__0 ) )
            // InternalMiniOCLCS.g:1281:2: ( rule__ImportCS__Group_1__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:1282:2: ( rule__ImportCS__Group_1__0 )
            // InternalMiniOCLCS.g:1282:3: rule__ImportCS__Group_1__0
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__Group_1__0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getGroup_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__2"
    // InternalMiniOCLCS.g:1290:1: rule__ImportCS__Group__2 : rule__ImportCS__Group__2__Impl rule__ImportCS__Group__3 ;
    public final void rule__ImportCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1294:1: ( rule__ImportCS__Group__2__Impl rule__ImportCS__Group__3 )
            // InternalMiniOCLCS.g:1295:2: rule__ImportCS__Group__2__Impl rule__ImportCS__Group__3
            {
            pushFollow(FOLLOW_8);
            rule__ImportCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__2__Impl"
    // InternalMiniOCLCS.g:1302:1: rule__ImportCS__Group__2__Impl : ( ( rule__ImportCS__UriAssignment_2 ) ) ;
    public final void rule__ImportCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1306:1: ( ( ( rule__ImportCS__UriAssignment_2 ) ) )
            // InternalMiniOCLCS.g:1307:1: ( ( rule__ImportCS__UriAssignment_2 ) )
            {
            // InternalMiniOCLCS.g:1307:1: ( ( rule__ImportCS__UriAssignment_2 ) )
            // InternalMiniOCLCS.g:1308:2: ( rule__ImportCS__UriAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getUriAssignment_2()); 
            }
            // InternalMiniOCLCS.g:1309:2: ( rule__ImportCS__UriAssignment_2 )
            // InternalMiniOCLCS.g:1309:3: rule__ImportCS__UriAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__UriAssignment_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getUriAssignment_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__3"
    // InternalMiniOCLCS.g:1317:1: rule__ImportCS__Group__3 : rule__ImportCS__Group__3__Impl ;
    public final void rule__ImportCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1321:1: ( rule__ImportCS__Group__3__Impl )
            // InternalMiniOCLCS.g:1322:2: rule__ImportCS__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__Group__3__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group__3__Impl"
    // InternalMiniOCLCS.g:1328:1: rule__ImportCS__Group__3__Impl : ( ';' ) ;
    public final void rule__ImportCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1332:1: ( ( ';' ) )
            // InternalMiniOCLCS.g:1333:1: ( ';' )
            {
            // InternalMiniOCLCS.g:1333:1: ( ';' )
            // InternalMiniOCLCS.g:1334:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getSemicolonKeyword_3()); 
            }
            match(input,18,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getSemicolonKeyword_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group_1__0"
    // InternalMiniOCLCS.g:1344:1: rule__ImportCS__Group_1__0 : rule__ImportCS__Group_1__0__Impl rule__ImportCS__Group_1__1 ;
    public final void rule__ImportCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1348:1: ( rule__ImportCS__Group_1__0__Impl rule__ImportCS__Group_1__1 )
            // InternalMiniOCLCS.g:1349:2: rule__ImportCS__Group_1__0__Impl rule__ImportCS__Group_1__1
            {
            pushFollow(FOLLOW_9);
            rule__ImportCS__Group_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:1356:1: rule__ImportCS__Group_1__0__Impl : ( ( rule__ImportCS__AliasAssignment_1_0 ) ) ;
    public final void rule__ImportCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1360:1: ( ( ( rule__ImportCS__AliasAssignment_1_0 ) ) )
            // InternalMiniOCLCS.g:1361:1: ( ( rule__ImportCS__AliasAssignment_1_0 ) )
            {
            // InternalMiniOCLCS.g:1361:1: ( ( rule__ImportCS__AliasAssignment_1_0 ) )
            // InternalMiniOCLCS.g:1362:2: ( rule__ImportCS__AliasAssignment_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getAliasAssignment_1_0()); 
            }
            // InternalMiniOCLCS.g:1363:2: ( rule__ImportCS__AliasAssignment_1_0 )
            // InternalMiniOCLCS.g:1363:3: rule__ImportCS__AliasAssignment_1_0
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__AliasAssignment_1_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getAliasAssignment_1_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ImportCS__Group_1__1"
    // InternalMiniOCLCS.g:1371:1: rule__ImportCS__Group_1__1 : rule__ImportCS__Group_1__1__Impl ;
    public final void rule__ImportCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1375:1: ( rule__ImportCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:1376:2: rule__ImportCS__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ImportCS__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__ImportCS__Group_1__1"


    // $ANTLR start "rule__ImportCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:1382:1: rule__ImportCS__Group_1__1__Impl : ( ':' ) ;
    public final void rule__ImportCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1386:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:1387:1: ( ':' )
            {
            // InternalMiniOCLCS.g:1387:1: ( ':' )
            // InternalMiniOCLCS.g:1388:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getColonKeyword_1_1()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getColonKeyword_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__0"
    // InternalMiniOCLCS.g:1398:1: rule__PackageCS__Group__0 : rule__PackageCS__Group__0__Impl rule__PackageCS__Group__1 ;
    public final void rule__PackageCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1402:1: ( rule__PackageCS__Group__0__Impl rule__PackageCS__Group__1 )
            // InternalMiniOCLCS.g:1403:2: rule__PackageCS__Group__0__Impl rule__PackageCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__PackageCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__0__Impl"
    // InternalMiniOCLCS.g:1410:1: rule__PackageCS__Group__0__Impl : ( 'package' ) ;
    public final void rule__PackageCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1414:1: ( ( 'package' ) )
            // InternalMiniOCLCS.g:1415:1: ( 'package' )
            {
            // InternalMiniOCLCS.g:1415:1: ( 'package' )
            // InternalMiniOCLCS.g:1416:2: 'package'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getPackageKeyword_0()); 
            }
            match(input,20,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getPackageKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__1"
    // InternalMiniOCLCS.g:1425:1: rule__PackageCS__Group__1 : rule__PackageCS__Group__1__Impl rule__PackageCS__Group__2 ;
    public final void rule__PackageCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1429:1: ( rule__PackageCS__Group__1__Impl rule__PackageCS__Group__2 )
            // InternalMiniOCLCS.g:1430:2: rule__PackageCS__Group__1__Impl rule__PackageCS__Group__2
            {
            pushFollow(FOLLOW_10);
            rule__PackageCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__1__Impl"
    // InternalMiniOCLCS.g:1437:1: rule__PackageCS__Group__1__Impl : ( ( rule__PackageCS__NameAssignment_1 ) ) ;
    public final void rule__PackageCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1441:1: ( ( ( rule__PackageCS__NameAssignment_1 ) ) )
            // InternalMiniOCLCS.g:1442:1: ( ( rule__PackageCS__NameAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:1442:1: ( ( rule__PackageCS__NameAssignment_1 ) )
            // InternalMiniOCLCS.g:1443:2: ( rule__PackageCS__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getNameAssignment_1()); 
            }
            // InternalMiniOCLCS.g:1444:2: ( rule__PackageCS__NameAssignment_1 )
            // InternalMiniOCLCS.g:1444:3: rule__PackageCS__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__PackageCS__NameAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getNameAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__2"
    // InternalMiniOCLCS.g:1452:1: rule__PackageCS__Group__2 : rule__PackageCS__Group__2__Impl rule__PackageCS__Group__3 ;
    public final void rule__PackageCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1456:1: ( rule__PackageCS__Group__2__Impl rule__PackageCS__Group__3 )
            // InternalMiniOCLCS.g:1457:2: rule__PackageCS__Group__2__Impl rule__PackageCS__Group__3
            {
            pushFollow(FOLLOW_11);
            rule__PackageCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__2__Impl"
    // InternalMiniOCLCS.g:1464:1: rule__PackageCS__Group__2__Impl : ( '{' ) ;
    public final void rule__PackageCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1468:1: ( ( '{' ) )
            // InternalMiniOCLCS.g:1469:1: ( '{' )
            {
            // InternalMiniOCLCS.g:1469:1: ( '{' )
            // InternalMiniOCLCS.g:1470:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getLeftCurlyBracketKeyword_2()); 
            }
            match(input,21,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getLeftCurlyBracketKeyword_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__3"
    // InternalMiniOCLCS.g:1479:1: rule__PackageCS__Group__3 : rule__PackageCS__Group__3__Impl rule__PackageCS__Group__4 ;
    public final void rule__PackageCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1483:1: ( rule__PackageCS__Group__3__Impl rule__PackageCS__Group__4 )
            // InternalMiniOCLCS.g:1484:2: rule__PackageCS__Group__3__Impl rule__PackageCS__Group__4
            {
            pushFollow(FOLLOW_11);
            rule__PackageCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__3__Impl"
    // InternalMiniOCLCS.g:1491:1: rule__PackageCS__Group__3__Impl : ( ( rule__PackageCS__Alternatives_3 )* ) ;
    public final void rule__PackageCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1495:1: ( ( ( rule__PackageCS__Alternatives_3 )* ) )
            // InternalMiniOCLCS.g:1496:1: ( ( rule__PackageCS__Alternatives_3 )* )
            {
            // InternalMiniOCLCS.g:1496:1: ( ( rule__PackageCS__Alternatives_3 )* )
            // InternalMiniOCLCS.g:1497:2: ( rule__PackageCS__Alternatives_3 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getAlternatives_3()); 
            }
            // InternalMiniOCLCS.g:1498:2: ( rule__PackageCS__Alternatives_3 )*
            loop15:
            do {
                int alt15=2;
                int LA15_0 = input.LA(1);

                if ( (LA15_0==20||LA15_0==23) ) {
                    alt15=1;
                }


                switch (alt15) {
            	case 1 :
            	    // InternalMiniOCLCS.g:1498:3: rule__PackageCS__Alternatives_3
            	    {
            	    pushFollow(FOLLOW_12);
            	    rule__PackageCS__Alternatives_3();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getAlternatives_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__4"
    // InternalMiniOCLCS.g:1506:1: rule__PackageCS__Group__4 : rule__PackageCS__Group__4__Impl ;
    public final void rule__PackageCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1510:1: ( rule__PackageCS__Group__4__Impl )
            // InternalMiniOCLCS.g:1511:2: rule__PackageCS__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PackageCS__Group__4__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PackageCS__Group__4__Impl"
    // InternalMiniOCLCS.g:1517:1: rule__PackageCS__Group__4__Impl : ( '}' ) ;
    public final void rule__PackageCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1521:1: ( ( '}' ) )
            // InternalMiniOCLCS.g:1522:1: ( '}' )
            {
            // InternalMiniOCLCS.g:1522:1: ( '}' )
            // InternalMiniOCLCS.g:1523:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getRightCurlyBracketKeyword_4()); 
            }
            match(input,22,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getRightCurlyBracketKeyword_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__0"
    // InternalMiniOCLCS.g:1533:1: rule__ClassCS__Group__0 : rule__ClassCS__Group__0__Impl rule__ClassCS__Group__1 ;
    public final void rule__ClassCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1537:1: ( rule__ClassCS__Group__0__Impl rule__ClassCS__Group__1 )
            // InternalMiniOCLCS.g:1538:2: rule__ClassCS__Group__0__Impl rule__ClassCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ClassCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__0__Impl"
    // InternalMiniOCLCS.g:1545:1: rule__ClassCS__Group__0__Impl : ( 'class' ) ;
    public final void rule__ClassCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1549:1: ( ( 'class' ) )
            // InternalMiniOCLCS.g:1550:1: ( 'class' )
            {
            // InternalMiniOCLCS.g:1550:1: ( 'class' )
            // InternalMiniOCLCS.g:1551:2: 'class'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getClassKeyword_0()); 
            }
            match(input,23,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getClassKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__1"
    // InternalMiniOCLCS.g:1560:1: rule__ClassCS__Group__1 : rule__ClassCS__Group__1__Impl rule__ClassCS__Group__2 ;
    public final void rule__ClassCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1564:1: ( rule__ClassCS__Group__1__Impl rule__ClassCS__Group__2 )
            // InternalMiniOCLCS.g:1565:2: rule__ClassCS__Group__1__Impl rule__ClassCS__Group__2
            {
            pushFollow(FOLLOW_13);
            rule__ClassCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__1__Impl"
    // InternalMiniOCLCS.g:1572:1: rule__ClassCS__Group__1__Impl : ( ( rule__ClassCS__NameAssignment_1 ) ) ;
    public final void rule__ClassCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1576:1: ( ( ( rule__ClassCS__NameAssignment_1 ) ) )
            // InternalMiniOCLCS.g:1577:1: ( ( rule__ClassCS__NameAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:1577:1: ( ( rule__ClassCS__NameAssignment_1 ) )
            // InternalMiniOCLCS.g:1578:2: ( rule__ClassCS__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getNameAssignment_1()); 
            }
            // InternalMiniOCLCS.g:1579:2: ( rule__ClassCS__NameAssignment_1 )
            // InternalMiniOCLCS.g:1579:3: rule__ClassCS__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ClassCS__NameAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getNameAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__2"
    // InternalMiniOCLCS.g:1587:1: rule__ClassCS__Group__2 : rule__ClassCS__Group__2__Impl rule__ClassCS__Group__3 ;
    public final void rule__ClassCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1591:1: ( rule__ClassCS__Group__2__Impl rule__ClassCS__Group__3 )
            // InternalMiniOCLCS.g:1592:2: rule__ClassCS__Group__2__Impl rule__ClassCS__Group__3
            {
            pushFollow(FOLLOW_13);
            rule__ClassCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__2__Impl"
    // InternalMiniOCLCS.g:1599:1: rule__ClassCS__Group__2__Impl : ( ( rule__ClassCS__Group_2__0 )? ) ;
    public final void rule__ClassCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1603:1: ( ( ( rule__ClassCS__Group_2__0 )? ) )
            // InternalMiniOCLCS.g:1604:1: ( ( rule__ClassCS__Group_2__0 )? )
            {
            // InternalMiniOCLCS.g:1604:1: ( ( rule__ClassCS__Group_2__0 )? )
            // InternalMiniOCLCS.g:1605:2: ( rule__ClassCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getGroup_2()); 
            }
            // InternalMiniOCLCS.g:1606:2: ( rule__ClassCS__Group_2__0 )?
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==24) ) {
                alt16=1;
            }
            switch (alt16) {
                case 1 :
                    // InternalMiniOCLCS.g:1606:3: rule__ClassCS__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__ClassCS__Group_2__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getGroup_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__3"
    // InternalMiniOCLCS.g:1614:1: rule__ClassCS__Group__3 : rule__ClassCS__Group__3__Impl rule__ClassCS__Group__4 ;
    public final void rule__ClassCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1618:1: ( rule__ClassCS__Group__3__Impl rule__ClassCS__Group__4 )
            // InternalMiniOCLCS.g:1619:2: rule__ClassCS__Group__3__Impl rule__ClassCS__Group__4
            {
            pushFollow(FOLLOW_14);
            rule__ClassCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__3__Impl"
    // InternalMiniOCLCS.g:1626:1: rule__ClassCS__Group__3__Impl : ( '{' ) ;
    public final void rule__ClassCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1630:1: ( ( '{' ) )
            // InternalMiniOCLCS.g:1631:1: ( '{' )
            {
            // InternalMiniOCLCS.g:1631:1: ( '{' )
            // InternalMiniOCLCS.g:1632:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getLeftCurlyBracketKeyword_3()); 
            }
            match(input,21,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getLeftCurlyBracketKeyword_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__4"
    // InternalMiniOCLCS.g:1641:1: rule__ClassCS__Group__4 : rule__ClassCS__Group__4__Impl rule__ClassCS__Group__5 ;
    public final void rule__ClassCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1645:1: ( rule__ClassCS__Group__4__Impl rule__ClassCS__Group__5 )
            // InternalMiniOCLCS.g:1646:2: rule__ClassCS__Group__4__Impl rule__ClassCS__Group__5
            {
            pushFollow(FOLLOW_14);
            rule__ClassCS__Group__4__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__4__Impl"
    // InternalMiniOCLCS.g:1653:1: rule__ClassCS__Group__4__Impl : ( ( rule__ClassCS__Alternatives_4 )* ) ;
    public final void rule__ClassCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1657:1: ( ( ( rule__ClassCS__Alternatives_4 )* ) )
            // InternalMiniOCLCS.g:1658:1: ( ( rule__ClassCS__Alternatives_4 )* )
            {
            // InternalMiniOCLCS.g:1658:1: ( ( rule__ClassCS__Alternatives_4 )* )
            // InternalMiniOCLCS.g:1659:2: ( rule__ClassCS__Alternatives_4 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getAlternatives_4()); 
            }
            // InternalMiniOCLCS.g:1660:2: ( rule__ClassCS__Alternatives_4 )*
            loop17:
            do {
                int alt17=2;
                int LA17_0 = input.LA(1);

                if ( (LA17_0==25||LA17_0==29) ) {
                    alt17=1;
                }


                switch (alt17) {
            	case 1 :
            	    // InternalMiniOCLCS.g:1660:3: rule__ClassCS__Alternatives_4
            	    {
            	    pushFollow(FOLLOW_15);
            	    rule__ClassCS__Alternatives_4();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getAlternatives_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__5"
    // InternalMiniOCLCS.g:1668:1: rule__ClassCS__Group__5 : rule__ClassCS__Group__5__Impl ;
    public final void rule__ClassCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1672:1: ( rule__ClassCS__Group__5__Impl )
            // InternalMiniOCLCS.g:1673:2: rule__ClassCS__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassCS__Group__5__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group__5__Impl"
    // InternalMiniOCLCS.g:1679:1: rule__ClassCS__Group__5__Impl : ( '}' ) ;
    public final void rule__ClassCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1683:1: ( ( '}' ) )
            // InternalMiniOCLCS.g:1684:1: ( '}' )
            {
            // InternalMiniOCLCS.g:1684:1: ( '}' )
            // InternalMiniOCLCS.g:1685:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getRightCurlyBracketKeyword_5()); 
            }
            match(input,22,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getRightCurlyBracketKeyword_5()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group_2__0"
    // InternalMiniOCLCS.g:1695:1: rule__ClassCS__Group_2__0 : rule__ClassCS__Group_2__0__Impl rule__ClassCS__Group_2__1 ;
    public final void rule__ClassCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1699:1: ( rule__ClassCS__Group_2__0__Impl rule__ClassCS__Group_2__1 )
            // InternalMiniOCLCS.g:1700:2: rule__ClassCS__Group_2__0__Impl rule__ClassCS__Group_2__1
            {
            pushFollow(FOLLOW_6);
            rule__ClassCS__Group_2__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group_2__0__Impl"
    // InternalMiniOCLCS.g:1707:1: rule__ClassCS__Group_2__0__Impl : ( 'extends' ) ;
    public final void rule__ClassCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1711:1: ( ( 'extends' ) )
            // InternalMiniOCLCS.g:1712:1: ( 'extends' )
            {
            // InternalMiniOCLCS.g:1712:1: ( 'extends' )
            // InternalMiniOCLCS.g:1713:2: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getExtendsKeyword_2_0()); 
            }
            match(input,24,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getExtendsKeyword_2_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ClassCS__Group_2__1"
    // InternalMiniOCLCS.g:1722:1: rule__ClassCS__Group_2__1 : rule__ClassCS__Group_2__1__Impl ;
    public final void rule__ClassCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1726:1: ( rule__ClassCS__Group_2__1__Impl )
            // InternalMiniOCLCS.g:1727:2: rule__ClassCS__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ClassCS__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__ClassCS__Group_2__1"


    // $ANTLR start "rule__ClassCS__Group_2__1__Impl"
    // InternalMiniOCLCS.g:1733:1: rule__ClassCS__Group_2__1__Impl : ( ( rule__ClassCS__ExtendsAssignment_2_1 ) ) ;
    public final void rule__ClassCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1737:1: ( ( ( rule__ClassCS__ExtendsAssignment_2_1 ) ) )
            // InternalMiniOCLCS.g:1738:1: ( ( rule__ClassCS__ExtendsAssignment_2_1 ) )
            {
            // InternalMiniOCLCS.g:1738:1: ( ( rule__ClassCS__ExtendsAssignment_2_1 ) )
            // InternalMiniOCLCS.g:1739:2: ( rule__ClassCS__ExtendsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getExtendsAssignment_2_1()); 
            }
            // InternalMiniOCLCS.g:1740:2: ( rule__ClassCS__ExtendsAssignment_2_1 )
            // InternalMiniOCLCS.g:1740:3: rule__ClassCS__ExtendsAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__ClassCS__ExtendsAssignment_2_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getExtendsAssignment_2_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__0"
    // InternalMiniOCLCS.g:1749:1: rule__PropertyCS__Group__0 : rule__PropertyCS__Group__0__Impl rule__PropertyCS__Group__1 ;
    public final void rule__PropertyCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1753:1: ( rule__PropertyCS__Group__0__Impl rule__PropertyCS__Group__1 )
            // InternalMiniOCLCS.g:1754:2: rule__PropertyCS__Group__0__Impl rule__PropertyCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__PropertyCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__0__Impl"
    // InternalMiniOCLCS.g:1761:1: rule__PropertyCS__Group__0__Impl : ( 'prop' ) ;
    public final void rule__PropertyCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1765:1: ( ( 'prop' ) )
            // InternalMiniOCLCS.g:1766:1: ( 'prop' )
            {
            // InternalMiniOCLCS.g:1766:1: ( 'prop' )
            // InternalMiniOCLCS.g:1767:2: 'prop'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getPropKeyword_0()); 
            }
            match(input,25,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getPropKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__1"
    // InternalMiniOCLCS.g:1776:1: rule__PropertyCS__Group__1 : rule__PropertyCS__Group__1__Impl rule__PropertyCS__Group__2 ;
    public final void rule__PropertyCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1780:1: ( rule__PropertyCS__Group__1__Impl rule__PropertyCS__Group__2 )
            // InternalMiniOCLCS.g:1781:2: rule__PropertyCS__Group__1__Impl rule__PropertyCS__Group__2
            {
            pushFollow(FOLLOW_9);
            rule__PropertyCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__1__Impl"
    // InternalMiniOCLCS.g:1788:1: rule__PropertyCS__Group__1__Impl : ( ( rule__PropertyCS__NameAssignment_1 ) ) ;
    public final void rule__PropertyCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1792:1: ( ( ( rule__PropertyCS__NameAssignment_1 ) ) )
            // InternalMiniOCLCS.g:1793:1: ( ( rule__PropertyCS__NameAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:1793:1: ( ( rule__PropertyCS__NameAssignment_1 ) )
            // InternalMiniOCLCS.g:1794:2: ( rule__PropertyCS__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getNameAssignment_1()); 
            }
            // InternalMiniOCLCS.g:1795:2: ( rule__PropertyCS__NameAssignment_1 )
            // InternalMiniOCLCS.g:1795:3: rule__PropertyCS__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__PropertyCS__NameAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getNameAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__2"
    // InternalMiniOCLCS.g:1803:1: rule__PropertyCS__Group__2 : rule__PropertyCS__Group__2__Impl rule__PropertyCS__Group__3 ;
    public final void rule__PropertyCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1807:1: ( rule__PropertyCS__Group__2__Impl rule__PropertyCS__Group__3 )
            // InternalMiniOCLCS.g:1808:2: rule__PropertyCS__Group__2__Impl rule__PropertyCS__Group__3
            {
            pushFollow(FOLLOW_6);
            rule__PropertyCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__2__Impl"
    // InternalMiniOCLCS.g:1815:1: rule__PropertyCS__Group__2__Impl : ( ':' ) ;
    public final void rule__PropertyCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1819:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:1820:1: ( ':' )
            {
            // InternalMiniOCLCS.g:1820:1: ( ':' )
            // InternalMiniOCLCS.g:1821:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getColonKeyword_2()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getColonKeyword_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__3"
    // InternalMiniOCLCS.g:1830:1: rule__PropertyCS__Group__3 : rule__PropertyCS__Group__3__Impl rule__PropertyCS__Group__4 ;
    public final void rule__PropertyCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1834:1: ( rule__PropertyCS__Group__3__Impl rule__PropertyCS__Group__4 )
            // InternalMiniOCLCS.g:1835:2: rule__PropertyCS__Group__3__Impl rule__PropertyCS__Group__4
            {
            pushFollow(FOLLOW_16);
            rule__PropertyCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__3__Impl"
    // InternalMiniOCLCS.g:1842:1: rule__PropertyCS__Group__3__Impl : ( ( rule__PropertyCS__TypeRefAssignment_3 ) ) ;
    public final void rule__PropertyCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1846:1: ( ( ( rule__PropertyCS__TypeRefAssignment_3 ) ) )
            // InternalMiniOCLCS.g:1847:1: ( ( rule__PropertyCS__TypeRefAssignment_3 ) )
            {
            // InternalMiniOCLCS.g:1847:1: ( ( rule__PropertyCS__TypeRefAssignment_3 ) )
            // InternalMiniOCLCS.g:1848:2: ( rule__PropertyCS__TypeRefAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getTypeRefAssignment_3()); 
            }
            // InternalMiniOCLCS.g:1849:2: ( rule__PropertyCS__TypeRefAssignment_3 )
            // InternalMiniOCLCS.g:1849:3: rule__PropertyCS__TypeRefAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__PropertyCS__TypeRefAssignment_3();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getTypeRefAssignment_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__4"
    // InternalMiniOCLCS.g:1857:1: rule__PropertyCS__Group__4 : rule__PropertyCS__Group__4__Impl rule__PropertyCS__Group__5 ;
    public final void rule__PropertyCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1861:1: ( rule__PropertyCS__Group__4__Impl rule__PropertyCS__Group__5 )
            // InternalMiniOCLCS.g:1862:2: rule__PropertyCS__Group__4__Impl rule__PropertyCS__Group__5
            {
            pushFollow(FOLLOW_16);
            rule__PropertyCS__Group__4__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__4__Impl"
    // InternalMiniOCLCS.g:1869:1: rule__PropertyCS__Group__4__Impl : ( ( rule__PropertyCS__MultiplicityAssignment_4 )? ) ;
    public final void rule__PropertyCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1873:1: ( ( ( rule__PropertyCS__MultiplicityAssignment_4 )? ) )
            // InternalMiniOCLCS.g:1874:1: ( ( rule__PropertyCS__MultiplicityAssignment_4 )? )
            {
            // InternalMiniOCLCS.g:1874:1: ( ( rule__PropertyCS__MultiplicityAssignment_4 )? )
            // InternalMiniOCLCS.g:1875:2: ( rule__PropertyCS__MultiplicityAssignment_4 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getMultiplicityAssignment_4()); 
            }
            // InternalMiniOCLCS.g:1876:2: ( rule__PropertyCS__MultiplicityAssignment_4 )?
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==26) ) {
                alt18=1;
            }
            switch (alt18) {
                case 1 :
                    // InternalMiniOCLCS.g:1876:3: rule__PropertyCS__MultiplicityAssignment_4
                    {
                    pushFollow(FOLLOW_2);
                    rule__PropertyCS__MultiplicityAssignment_4();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getMultiplicityAssignment_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__5"
    // InternalMiniOCLCS.g:1884:1: rule__PropertyCS__Group__5 : rule__PropertyCS__Group__5__Impl ;
    public final void rule__PropertyCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1888:1: ( rule__PropertyCS__Group__5__Impl )
            // InternalMiniOCLCS.g:1889:2: rule__PropertyCS__Group__5__Impl
            {
            pushFollow(FOLLOW_2);
            rule__PropertyCS__Group__5__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__PropertyCS__Group__5__Impl"
    // InternalMiniOCLCS.g:1895:1: rule__PropertyCS__Group__5__Impl : ( ';' ) ;
    public final void rule__PropertyCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1899:1: ( ( ';' ) )
            // InternalMiniOCLCS.g:1900:1: ( ';' )
            {
            // InternalMiniOCLCS.g:1900:1: ( ';' )
            // InternalMiniOCLCS.g:1901:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getSemicolonKeyword_5()); 
            }
            match(input,18,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getSemicolonKeyword_5()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Group__0"
    // InternalMiniOCLCS.g:1911: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 {
            // InternalMiniOCLCS.g:1915:1: ( rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 )
            // InternalMiniOCLCS.g:1916:2: rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1
            {
            pushFollow(FOLLOW_17);
            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"
    // InternalMiniOCLCS.g:1923:1: rule__MultiplicityCS__Group__0__Impl : ( '[' ) ;
    public final void rule__MultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1927:1: ( ( '[' ) )
            // InternalMiniOCLCS.g:1928:1: ( '[' )
            {
            // InternalMiniOCLCS.g:1928:1: ( '[' )
            // InternalMiniOCLCS.g:1929:2: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0()); 
            }
            match(input,26,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"
    // InternalMiniOCLCS.g:1938: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 {
            // InternalMiniOCLCS.g:1942:1: ( rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 )
            // InternalMiniOCLCS.g:1943:2: rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2
            {
            pushFollow(FOLLOW_18);
            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"
    // InternalMiniOCLCS.g:1950:1: rule__MultiplicityCS__Group__1__Impl : ( ( rule__MultiplicityCS__Alternatives_1 ) ) ;
    public final void rule__MultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1954:1: ( ( ( rule__MultiplicityCS__Alternatives_1 ) ) )
            // InternalMiniOCLCS.g:1955:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            {
            // InternalMiniOCLCS.g:1955:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            // InternalMiniOCLCS.g:1956:2: ( rule__MultiplicityCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1()); 
            }
            // InternalMiniOCLCS.g:1957:2: ( rule__MultiplicityCS__Alternatives_1 )
            // InternalMiniOCLCS.g:1957: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"
    // InternalMiniOCLCS.g:1965:1: rule__MultiplicityCS__Group__2 : rule__MultiplicityCS__Group__2__Impl ;
    public final void rule__MultiplicityCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1969:1: ( rule__MultiplicityCS__Group__2__Impl )
            // InternalMiniOCLCS.g:1970:2: rule__MultiplicityCS__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicityCS__Group__2__Impl();

            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"
    // InternalMiniOCLCS.g:1976:1: rule__MultiplicityCS__Group__2__Impl : ( ']' ) ;
    public final void rule__MultiplicityCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1980:1: ( ( ']' ) )
            // InternalMiniOCLCS.g:1981:1: ( ']' )
            {
            // InternalMiniOCLCS.g:1981:1: ( ']' )
            // InternalMiniOCLCS.g:1982:2: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_2()); 
            }
            match(input,27,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_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_1_3__0"
    // InternalMiniOCLCS.g:1992:1: rule__MultiplicityCS__Group_1_3__0 : rule__MultiplicityCS__Group_1_3__0__Impl rule__MultiplicityCS__Group_1_3__1 ;
    public final void rule__MultiplicityCS__Group_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:1996:1: ( rule__MultiplicityCS__Group_1_3__0__Impl rule__MultiplicityCS__Group_1_3__1 )
            // InternalMiniOCLCS.g:1997:2: rule__MultiplicityCS__Group_1_3__0__Impl rule__MultiplicityCS__Group_1_3__1
            {
            pushFollow(FOLLOW_19);
            rule__MultiplicityCS__Group_1_3__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Group_1_3__0__Impl"
    // InternalMiniOCLCS.g:2004:1: rule__MultiplicityCS__Group_1_3__0__Impl : ( ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 ) ) ;
    public final void rule__MultiplicityCS__Group_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2008:1: ( ( ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 ) ) )
            // InternalMiniOCLCS.g:2009:1: ( ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 ) )
            {
            // InternalMiniOCLCS.g:2009:1: ( ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 ) )
            // InternalMiniOCLCS.g:2010:2: ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLowerIntAssignment_1_3_0()); 
            }
            // InternalMiniOCLCS.g:2011:2: ( rule__MultiplicityCS__LowerIntAssignment_1_3_0 )
            // InternalMiniOCLCS.g:2011:3: rule__MultiplicityCS__LowerIntAssignment_1_3_0
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicityCS__LowerIntAssignment_1_3_0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Group_1_3__1"
    // InternalMiniOCLCS.g:2019:1: rule__MultiplicityCS__Group_1_3__1 : rule__MultiplicityCS__Group_1_3__1__Impl rule__MultiplicityCS__Group_1_3__2 ;
    public final void rule__MultiplicityCS__Group_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2023:1: ( rule__MultiplicityCS__Group_1_3__1__Impl rule__MultiplicityCS__Group_1_3__2 )
            // InternalMiniOCLCS.g:2024:2: rule__MultiplicityCS__Group_1_3__1__Impl rule__MultiplicityCS__Group_1_3__2
            {
            pushFollow(FOLLOW_20);
            rule__MultiplicityCS__Group_1_3__1__Impl();

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


    // $ANTLR start "rule__MultiplicityCS__Group_1_3__1__Impl"
    // InternalMiniOCLCS.g:2031:1: rule__MultiplicityCS__Group_1_3__1__Impl : ( '..' ) ;
    public final void rule__MultiplicityCS__Group_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2035:1: ( ( '..' ) )
            // InternalMiniOCLCS.g:2036:1: ( '..' )
            {
            // InternalMiniOCLCS.g:2036:1: ( '..' )
            // InternalMiniOCLCS.g:2037:2: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getFullStopFullStopKeyword_1_3_1()); 
            }
            match(input,28,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getFullStopFullStopKeyword_1_3_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Group_1_3__2"
    // InternalMiniOCLCS.g:2046:1: rule__MultiplicityCS__Group_1_3__2 : rule__MultiplicityCS__Group_1_3__2__Impl ;
    public final void rule__MultiplicityCS__Group_1_3__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2050:1: ( rule__MultiplicityCS__Group_1_3__2__Impl )
            // InternalMiniOCLCS.g:2051:2: rule__MultiplicityCS__Group_1_3__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicityCS__Group_1_3__2__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__MultiplicityCS__Group_1_3__2__Impl"
    // InternalMiniOCLCS.g:2057:1: rule__MultiplicityCS__Group_1_3__2__Impl : ( ( rule__MultiplicityCS__Alternatives_1_3_2 ) ) ;
    public final void rule__MultiplicityCS__Group_1_3__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2061:1: ( ( ( rule__MultiplicityCS__Alternatives_1_3_2 ) ) )
            // InternalMiniOCLCS.g:2062:1: ( ( rule__MultiplicityCS__Alternatives_1_3_2 ) )
            {
            // InternalMiniOCLCS.g:2062:1: ( ( rule__MultiplicityCS__Alternatives_1_3_2 ) )
            // InternalMiniOCLCS.g:2063:2: ( rule__MultiplicityCS__Alternatives_1_3_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1_3_2()); 
            }
            // InternalMiniOCLCS.g:2064:2: ( rule__MultiplicityCS__Alternatives_1_3_2 )
            // InternalMiniOCLCS.g:2064:3: rule__MultiplicityCS__Alternatives_1_3_2
            {
            pushFollow(FOLLOW_2);
            rule__MultiplicityCS__Alternatives_1_3_2();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__0"
    // InternalMiniOCLCS.g:2073:1: rule__OperationCS__Group__0 : rule__OperationCS__Group__0__Impl rule__OperationCS__Group__1 ;
    public final void rule__OperationCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2077:1: ( rule__OperationCS__Group__0__Impl rule__OperationCS__Group__1 )
            // InternalMiniOCLCS.g:2078:2: rule__OperationCS__Group__0__Impl rule__OperationCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__OperationCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2085:1: rule__OperationCS__Group__0__Impl : ( 'op' ) ;
    public final void rule__OperationCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2089:1: ( ( 'op' ) )
            // InternalMiniOCLCS.g:2090:1: ( 'op' )
            {
            // InternalMiniOCLCS.g:2090:1: ( 'op' )
            // InternalMiniOCLCS.g:2091:2: 'op'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOpKeyword_0()); 
            }
            match(input,29,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOpKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__1"
    // InternalMiniOCLCS.g:2100:1: rule__OperationCS__Group__1 : rule__OperationCS__Group__1__Impl rule__OperationCS__Group__2 ;
    public final void rule__OperationCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2104:1: ( rule__OperationCS__Group__1__Impl rule__OperationCS__Group__2 )
            // InternalMiniOCLCS.g:2105:2: rule__OperationCS__Group__1__Impl rule__OperationCS__Group__2
            {
            pushFollow(FOLLOW_21);
            rule__OperationCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2112:1: rule__OperationCS__Group__1__Impl : ( ( rule__OperationCS__NameAssignment_1 ) ) ;
    public final void rule__OperationCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2116:1: ( ( ( rule__OperationCS__NameAssignment_1 ) ) )
            // InternalMiniOCLCS.g:2117:1: ( ( rule__OperationCS__NameAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:2117:1: ( ( rule__OperationCS__NameAssignment_1 ) )
            // InternalMiniOCLCS.g:2118:2: ( rule__OperationCS__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getNameAssignment_1()); 
            }
            // InternalMiniOCLCS.g:2119:2: ( rule__OperationCS__NameAssignment_1 )
            // InternalMiniOCLCS.g:2119:3: rule__OperationCS__NameAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__NameAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getNameAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__2"
    // InternalMiniOCLCS.g:2127:1: rule__OperationCS__Group__2 : rule__OperationCS__Group__2__Impl rule__OperationCS__Group__3 ;
    public final void rule__OperationCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2131:1: ( rule__OperationCS__Group__2__Impl rule__OperationCS__Group__3 )
            // InternalMiniOCLCS.g:2132:2: rule__OperationCS__Group__2__Impl rule__OperationCS__Group__3
            {
            pushFollow(FOLLOW_22);
            rule__OperationCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__2__Impl"
    // InternalMiniOCLCS.g:2139:1: rule__OperationCS__Group__2__Impl : ( '(' ) ;
    public final void rule__OperationCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2143:1: ( ( '(' ) )
            // InternalMiniOCLCS.g:2144:1: ( '(' )
            {
            // InternalMiniOCLCS.g:2144:1: ( '(' )
            // InternalMiniOCLCS.g:2145:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getLeftParenthesisKeyword_2()); 
            }
            match(input,30,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getLeftParenthesisKeyword_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__3"
    // InternalMiniOCLCS.g:2154:1: rule__OperationCS__Group__3 : rule__OperationCS__Group__3__Impl rule__OperationCS__Group__4 ;
    public final void rule__OperationCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2158:1: ( rule__OperationCS__Group__3__Impl rule__OperationCS__Group__4 )
            // InternalMiniOCLCS.g:2159:2: rule__OperationCS__Group__3__Impl rule__OperationCS__Group__4
            {
            pushFollow(FOLLOW_22);
            rule__OperationCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__3__Impl"
    // InternalMiniOCLCS.g:2166:1: rule__OperationCS__Group__3__Impl : ( ( rule__OperationCS__Group_3__0 )? ) ;
    public final void rule__OperationCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2170:1: ( ( ( rule__OperationCS__Group_3__0 )? ) )
            // InternalMiniOCLCS.g:2171:1: ( ( rule__OperationCS__Group_3__0 )? )
            {
            // InternalMiniOCLCS.g:2171:1: ( ( rule__OperationCS__Group_3__0 )? )
            // InternalMiniOCLCS.g:2172:2: ( rule__OperationCS__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_3()); 
            }
            // InternalMiniOCLCS.g:2173:2: ( rule__OperationCS__Group_3__0 )?
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==RULE_ID) ) {
                alt19=1;
            }
            switch (alt19) {
                case 1 :
                    // InternalMiniOCLCS.g:2173:3: rule__OperationCS__Group_3__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__OperationCS__Group_3__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__4"
    // InternalMiniOCLCS.g:2181:1: rule__OperationCS__Group__4 : rule__OperationCS__Group__4__Impl rule__OperationCS__Group__5 ;
    public final void rule__OperationCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2185:1: ( rule__OperationCS__Group__4__Impl rule__OperationCS__Group__5 )
            // InternalMiniOCLCS.g:2186:2: rule__OperationCS__Group__4__Impl rule__OperationCS__Group__5
            {
            pushFollow(FOLLOW_9);
            rule__OperationCS__Group__4__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__4__Impl"
    // InternalMiniOCLCS.g:2193:1: rule__OperationCS__Group__4__Impl : ( ')' ) ;
    public final void rule__OperationCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2197:1: ( ( ')' ) )
            // InternalMiniOCLCS.g:2198:1: ( ')' )
            {
            // InternalMiniOCLCS.g:2198:1: ( ')' )
            // InternalMiniOCLCS.g:2199:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getRightParenthesisKeyword_4()); 
            }
            match(input,31,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getRightParenthesisKeyword_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__5"
    // InternalMiniOCLCS.g:2208:1: rule__OperationCS__Group__5 : rule__OperationCS__Group__5__Impl rule__OperationCS__Group__6 ;
    public final void rule__OperationCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2212:1: ( rule__OperationCS__Group__5__Impl rule__OperationCS__Group__6 )
            // InternalMiniOCLCS.g:2213:2: rule__OperationCS__Group__5__Impl rule__OperationCS__Group__6
            {
            pushFollow(FOLLOW_6);
            rule__OperationCS__Group__5__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__5__Impl"
    // InternalMiniOCLCS.g:2220:1: rule__OperationCS__Group__5__Impl : ( ':' ) ;
    public final void rule__OperationCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2224:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:2225:1: ( ':' )
            {
            // InternalMiniOCLCS.g:2225:1: ( ':' )
            // InternalMiniOCLCS.g:2226:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getColonKeyword_5()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getColonKeyword_5()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__6"
    // InternalMiniOCLCS.g:2235:1: rule__OperationCS__Group__6 : rule__OperationCS__Group__6__Impl rule__OperationCS__Group__7 ;
    public final void rule__OperationCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2239:1: ( rule__OperationCS__Group__6__Impl rule__OperationCS__Group__7 )
            // InternalMiniOCLCS.g:2240:2: rule__OperationCS__Group__6__Impl rule__OperationCS__Group__7
            {
            pushFollow(FOLLOW_23);
            rule__OperationCS__Group__6__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__6__Impl"
    // InternalMiniOCLCS.g:2247:1: rule__OperationCS__Group__6__Impl : ( ( rule__OperationCS__ResultRefAssignment_6 ) ) ;
    public final void rule__OperationCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2251:1: ( ( ( rule__OperationCS__ResultRefAssignment_6 ) ) )
            // InternalMiniOCLCS.g:2252:1: ( ( rule__OperationCS__ResultRefAssignment_6 ) )
            {
            // InternalMiniOCLCS.g:2252:1: ( ( rule__OperationCS__ResultRefAssignment_6 ) )
            // InternalMiniOCLCS.g:2253:2: ( rule__OperationCS__ResultRefAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getResultRefAssignment_6()); 
            }
            // InternalMiniOCLCS.g:2254:2: ( rule__OperationCS__ResultRefAssignment_6 )
            // InternalMiniOCLCS.g:2254:3: rule__OperationCS__ResultRefAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__ResultRefAssignment_6();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getResultRefAssignment_6()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__7"
    // InternalMiniOCLCS.g:2262:1: rule__OperationCS__Group__7 : rule__OperationCS__Group__7__Impl rule__OperationCS__Group__8 ;
    public final void rule__OperationCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2266:1: ( rule__OperationCS__Group__7__Impl rule__OperationCS__Group__8 )
            // InternalMiniOCLCS.g:2267:2: rule__OperationCS__Group__7__Impl rule__OperationCS__Group__8
            {
            pushFollow(FOLLOW_24);
            rule__OperationCS__Group__7__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__7__Impl"
    // InternalMiniOCLCS.g:2274:1: rule__OperationCS__Group__7__Impl : ( '=' ) ;
    public final void rule__OperationCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2278:1: ( ( '=' ) )
            // InternalMiniOCLCS.g:2279:1: ( '=' )
            {
            // InternalMiniOCLCS.g:2279:1: ( '=' )
            // InternalMiniOCLCS.g:2280:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getEqualsSignKeyword_7()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getEqualsSignKeyword_7()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__8"
    // InternalMiniOCLCS.g:2289:1: rule__OperationCS__Group__8 : rule__OperationCS__Group__8__Impl rule__OperationCS__Group__9 ;
    public final void rule__OperationCS__Group__8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2293:1: ( rule__OperationCS__Group__8__Impl rule__OperationCS__Group__9 )
            // InternalMiniOCLCS.g:2294:2: rule__OperationCS__Group__8__Impl rule__OperationCS__Group__9
            {
            pushFollow(FOLLOW_8);
            rule__OperationCS__Group__8__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__8__Impl"
    // InternalMiniOCLCS.g:2301:1: rule__OperationCS__Group__8__Impl : ( ( rule__OperationCS__BodyAssignment_8 ) ) ;
    public final void rule__OperationCS__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2305:1: ( ( ( rule__OperationCS__BodyAssignment_8 ) ) )
            // InternalMiniOCLCS.g:2306:1: ( ( rule__OperationCS__BodyAssignment_8 ) )
            {
            // InternalMiniOCLCS.g:2306:1: ( ( rule__OperationCS__BodyAssignment_8 ) )
            // InternalMiniOCLCS.g:2307:2: ( rule__OperationCS__BodyAssignment_8 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getBodyAssignment_8()); 
            }
            // InternalMiniOCLCS.g:2308:2: ( rule__OperationCS__BodyAssignment_8 )
            // InternalMiniOCLCS.g:2308:3: rule__OperationCS__BodyAssignment_8
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__BodyAssignment_8();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getBodyAssignment_8()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__9"
    // InternalMiniOCLCS.g:2316:1: rule__OperationCS__Group__9 : rule__OperationCS__Group__9__Impl ;
    public final void rule__OperationCS__Group__9() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2320:1: ( rule__OperationCS__Group__9__Impl )
            // InternalMiniOCLCS.g:2321:2: rule__OperationCS__Group__9__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__Group__9__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group__9__Impl"
    // InternalMiniOCLCS.g:2327:1: rule__OperationCS__Group__9__Impl : ( ';' ) ;
    public final void rule__OperationCS__Group__9__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2331:1: ( ( ';' ) )
            // InternalMiniOCLCS.g:2332:1: ( ';' )
            {
            // InternalMiniOCLCS.g:2332:1: ( ';' )
            // InternalMiniOCLCS.g:2333:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getSemicolonKeyword_9()); 
            }
            match(input,18,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getSemicolonKeyword_9()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3__0"
    // InternalMiniOCLCS.g:2343:1: rule__OperationCS__Group_3__0 : rule__OperationCS__Group_3__0__Impl rule__OperationCS__Group_3__1 ;
    public final void rule__OperationCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2347:1: ( rule__OperationCS__Group_3__0__Impl rule__OperationCS__Group_3__1 )
            // InternalMiniOCLCS.g:2348:2: rule__OperationCS__Group_3__0__Impl rule__OperationCS__Group_3__1
            {
            pushFollow(FOLLOW_25);
            rule__OperationCS__Group_3__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3__0__Impl"
    // InternalMiniOCLCS.g:2355:1: rule__OperationCS__Group_3__0__Impl : ( ( rule__OperationCS__ParamsAssignment_3_0 ) ) ;
    public final void rule__OperationCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2359:1: ( ( ( rule__OperationCS__ParamsAssignment_3_0 ) ) )
            // InternalMiniOCLCS.g:2360:1: ( ( rule__OperationCS__ParamsAssignment_3_0 ) )
            {
            // InternalMiniOCLCS.g:2360:1: ( ( rule__OperationCS__ParamsAssignment_3_0 ) )
            // InternalMiniOCLCS.g:2361:2: ( rule__OperationCS__ParamsAssignment_3_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getParamsAssignment_3_0()); 
            }
            // InternalMiniOCLCS.g:2362:2: ( rule__OperationCS__ParamsAssignment_3_0 )
            // InternalMiniOCLCS.g:2362:3: rule__OperationCS__ParamsAssignment_3_0
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__ParamsAssignment_3_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getParamsAssignment_3_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3__1"
    // InternalMiniOCLCS.g:2370:1: rule__OperationCS__Group_3__1 : rule__OperationCS__Group_3__1__Impl ;
    public final void rule__OperationCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2374:1: ( rule__OperationCS__Group_3__1__Impl )
            // InternalMiniOCLCS.g:2375:2: rule__OperationCS__Group_3__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__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__OperationCS__Group_3__1"


    // $ANTLR start "rule__OperationCS__Group_3__1__Impl"
    // InternalMiniOCLCS.g:2381:1: rule__OperationCS__Group_3__1__Impl : ( ( rule__OperationCS__Group_3_1__0 )* ) ;
    public final void rule__OperationCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2385:1: ( ( ( rule__OperationCS__Group_3_1__0 )* ) )
            // InternalMiniOCLCS.g:2386:1: ( ( rule__OperationCS__Group_3_1__0 )* )
            {
            // InternalMiniOCLCS.g:2386:1: ( ( rule__OperationCS__Group_3_1__0 )* )
            // InternalMiniOCLCS.g:2387:2: ( rule__OperationCS__Group_3_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_3_1()); 
            }
            // InternalMiniOCLCS.g:2388:2: ( rule__OperationCS__Group_3_1__0 )*
            loop20:
            do {
                int alt20=2;
                int LA20_0 = input.LA(1);

                if ( (LA20_0==32) ) {
                    alt20=1;
                }


                switch (alt20) {
            	case 1 :
            	    // InternalMiniOCLCS.g:2388:3: rule__OperationCS__Group_3_1__0
            	    {
            	    pushFollow(FOLLOW_26);
            	    rule__OperationCS__Group_3_1__0();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_3_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3_1__0"
    // InternalMiniOCLCS.g:2397:1: rule__OperationCS__Group_3_1__0 : rule__OperationCS__Group_3_1__0__Impl rule__OperationCS__Group_3_1__1 ;
    public final void rule__OperationCS__Group_3_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2401:1: ( rule__OperationCS__Group_3_1__0__Impl rule__OperationCS__Group_3_1__1 )
            // InternalMiniOCLCS.g:2402:2: rule__OperationCS__Group_3_1__0__Impl rule__OperationCS__Group_3_1__1
            {
            pushFollow(FOLLOW_6);
            rule__OperationCS__Group_3_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3_1__0__Impl"
    // InternalMiniOCLCS.g:2409:1: rule__OperationCS__Group_3_1__0__Impl : ( ',' ) ;
    public final void rule__OperationCS__Group_3_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2413:1: ( ( ',' ) )
            // InternalMiniOCLCS.g:2414:1: ( ',' )
            {
            // InternalMiniOCLCS.g:2414:1: ( ',' )
            // InternalMiniOCLCS.g:2415:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getCommaKeyword_3_1_0()); 
            }
            match(input,32,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getCommaKeyword_3_1_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3_1__1"
    // InternalMiniOCLCS.g:2424:1: rule__OperationCS__Group_3_1__1 : rule__OperationCS__Group_3_1__1__Impl ;
    public final void rule__OperationCS__Group_3_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2428:1: ( rule__OperationCS__Group_3_1__1__Impl )
            // InternalMiniOCLCS.g:2429:2: rule__OperationCS__Group_3_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__Group_3_1__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__OperationCS__Group_3_1__1__Impl"
    // InternalMiniOCLCS.g:2435:1: rule__OperationCS__Group_3_1__1__Impl : ( ( rule__OperationCS__ParamsAssignment_3_1_1 ) ) ;
    public final void rule__OperationCS__Group_3_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2439:1: ( ( ( rule__OperationCS__ParamsAssignment_3_1_1 ) ) )
            // InternalMiniOCLCS.g:2440:1: ( ( rule__OperationCS__ParamsAssignment_3_1_1 ) )
            {
            // InternalMiniOCLCS.g:2440:1: ( ( rule__OperationCS__ParamsAssignment_3_1_1 ) )
            // InternalMiniOCLCS.g:2441:2: ( rule__OperationCS__ParamsAssignment_3_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getParamsAssignment_3_1_1()); 
            }
            // InternalMiniOCLCS.g:2442:2: ( rule__OperationCS__ParamsAssignment_3_1_1 )
            // InternalMiniOCLCS.g:2442:3: rule__OperationCS__ParamsAssignment_3_1_1
            {
            pushFollow(FOLLOW_2);
            rule__OperationCS__ParamsAssignment_3_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getParamsAssignment_3_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__0"
    // InternalMiniOCLCS.g:2451:1: rule__ParameterCS__Group__0 : rule__ParameterCS__Group__0__Impl rule__ParameterCS__Group__1 ;
    public final void rule__ParameterCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2455:1: ( rule__ParameterCS__Group__0__Impl rule__ParameterCS__Group__1 )
            // InternalMiniOCLCS.g:2456:2: rule__ParameterCS__Group__0__Impl rule__ParameterCS__Group__1
            {
            pushFollow(FOLLOW_9);
            rule__ParameterCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2463:1: rule__ParameterCS__Group__0__Impl : ( ( rule__ParameterCS__NameAssignment_0 ) ) ;
    public final void rule__ParameterCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2467:1: ( ( ( rule__ParameterCS__NameAssignment_0 ) ) )
            // InternalMiniOCLCS.g:2468:1: ( ( rule__ParameterCS__NameAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:2468:1: ( ( rule__ParameterCS__NameAssignment_0 ) )
            // InternalMiniOCLCS.g:2469:2: ( rule__ParameterCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getNameAssignment_0()); 
            }
            // InternalMiniOCLCS.g:2470:2: ( rule__ParameterCS__NameAssignment_0 )
            // InternalMiniOCLCS.g:2470:3: rule__ParameterCS__NameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__ParameterCS__NameAssignment_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getNameAssignment_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__1"
    // InternalMiniOCLCS.g:2478:1: rule__ParameterCS__Group__1 : rule__ParameterCS__Group__1__Impl rule__ParameterCS__Group__2 ;
    public final void rule__ParameterCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2482:1: ( rule__ParameterCS__Group__1__Impl rule__ParameterCS__Group__2 )
            // InternalMiniOCLCS.g:2483:2: rule__ParameterCS__Group__1__Impl rule__ParameterCS__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__ParameterCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2490:1: rule__ParameterCS__Group__1__Impl : ( ':' ) ;
    public final void rule__ParameterCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2494:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:2495:1: ( ':' )
            {
            // InternalMiniOCLCS.g:2495:1: ( ':' )
            // InternalMiniOCLCS.g:2496:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getColonKeyword_1()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getColonKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__2"
    // InternalMiniOCLCS.g:2505:1: rule__ParameterCS__Group__2 : rule__ParameterCS__Group__2__Impl ;
    public final void rule__ParameterCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2509:1: ( rule__ParameterCS__Group__2__Impl )
            // InternalMiniOCLCS.g:2510:2: rule__ParameterCS__Group__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ParameterCS__Group__2__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ParameterCS__Group__2__Impl"
    // InternalMiniOCLCS.g:2516:1: rule__ParameterCS__Group__2__Impl : ( ( rule__ParameterCS__TypeRefAssignment_2 ) ) ;
    public final void rule__ParameterCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2520:1: ( ( ( rule__ParameterCS__TypeRefAssignment_2 ) ) )
            // InternalMiniOCLCS.g:2521:1: ( ( rule__ParameterCS__TypeRefAssignment_2 ) )
            {
            // InternalMiniOCLCS.g:2521:1: ( ( rule__ParameterCS__TypeRefAssignment_2 ) )
            // InternalMiniOCLCS.g:2522:2: ( rule__ParameterCS__TypeRefAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getTypeRefAssignment_2()); 
            }
            // InternalMiniOCLCS.g:2523:2: ( rule__ParameterCS__TypeRefAssignment_2 )
            // InternalMiniOCLCS.g:2523:3: rule__ParameterCS__TypeRefAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__ParameterCS__TypeRefAssignment_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getTypeRefAssignment_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__0"
    // InternalMiniOCLCS.g:2532:1: rule__ConstraintsDefCS__Group__0 : rule__ConstraintsDefCS__Group__0__Impl rule__ConstraintsDefCS__Group__1 ;
    public final void rule__ConstraintsDefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2536:1: ( rule__ConstraintsDefCS__Group__0__Impl rule__ConstraintsDefCS__Group__1 )
            // InternalMiniOCLCS.g:2537:2: rule__ConstraintsDefCS__Group__0__Impl rule__ConstraintsDefCS__Group__1
            {
            pushFollow(FOLLOW_6);
            rule__ConstraintsDefCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2544:1: rule__ConstraintsDefCS__Group__0__Impl : ( 'context' ) ;
    public final void rule__ConstraintsDefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2548:1: ( ( 'context' ) )
            // InternalMiniOCLCS.g:2549:1: ( 'context' )
            {
            // InternalMiniOCLCS.g:2549:1: ( 'context' )
            // InternalMiniOCLCS.g:2550:2: 'context'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getContextKeyword_0()); 
            }
            match(input,33,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getContextKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__1"
    // InternalMiniOCLCS.g:2559:1: rule__ConstraintsDefCS__Group__1 : rule__ConstraintsDefCS__Group__1__Impl rule__ConstraintsDefCS__Group__2 ;
    public final void rule__ConstraintsDefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2563:1: ( rule__ConstraintsDefCS__Group__1__Impl rule__ConstraintsDefCS__Group__2 )
            // InternalMiniOCLCS.g:2564:2: rule__ConstraintsDefCS__Group__1__Impl rule__ConstraintsDefCS__Group__2
            {
            pushFollow(FOLLOW_10);
            rule__ConstraintsDefCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2571:1: rule__ConstraintsDefCS__Group__1__Impl : ( ( rule__ConstraintsDefCS__TypeRefAssignment_1 ) ) ;
    public final void rule__ConstraintsDefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2575:1: ( ( ( rule__ConstraintsDefCS__TypeRefAssignment_1 ) ) )
            // InternalMiniOCLCS.g:2576:1: ( ( rule__ConstraintsDefCS__TypeRefAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:2576:1: ( ( rule__ConstraintsDefCS__TypeRefAssignment_1 ) )
            // InternalMiniOCLCS.g:2577:2: ( rule__ConstraintsDefCS__TypeRefAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getTypeRefAssignment_1()); 
            }
            // InternalMiniOCLCS.g:2578:2: ( rule__ConstraintsDefCS__TypeRefAssignment_1 )
            // InternalMiniOCLCS.g:2578:3: rule__ConstraintsDefCS__TypeRefAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__ConstraintsDefCS__TypeRefAssignment_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getTypeRefAssignment_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__2"
    // InternalMiniOCLCS.g:2586:1: rule__ConstraintsDefCS__Group__2 : rule__ConstraintsDefCS__Group__2__Impl rule__ConstraintsDefCS__Group__3 ;
    public final void rule__ConstraintsDefCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2590:1: ( rule__ConstraintsDefCS__Group__2__Impl rule__ConstraintsDefCS__Group__3 )
            // InternalMiniOCLCS.g:2591:2: rule__ConstraintsDefCS__Group__2__Impl rule__ConstraintsDefCS__Group__3
            {
            pushFollow(FOLLOW_27);
            rule__ConstraintsDefCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__2__Impl"
    // InternalMiniOCLCS.g:2598:1: rule__ConstraintsDefCS__Group__2__Impl : ( '{' ) ;
    public final void rule__ConstraintsDefCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2602:1: ( ( '{' ) )
            // InternalMiniOCLCS.g:2603:1: ( '{' )
            {
            // InternalMiniOCLCS.g:2603:1: ( '{' )
            // InternalMiniOCLCS.g:2604:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getLeftCurlyBracketKeyword_2()); 
            }
            match(input,21,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getLeftCurlyBracketKeyword_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__3"
    // InternalMiniOCLCS.g:2613:1: rule__ConstraintsDefCS__Group__3 : rule__ConstraintsDefCS__Group__3__Impl rule__ConstraintsDefCS__Group__4 ;
    public final void rule__ConstraintsDefCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2617:1: ( rule__ConstraintsDefCS__Group__3__Impl rule__ConstraintsDefCS__Group__4 )
            // InternalMiniOCLCS.g:2618:2: rule__ConstraintsDefCS__Group__3__Impl rule__ConstraintsDefCS__Group__4
            {
            pushFollow(FOLLOW_27);
            rule__ConstraintsDefCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__3__Impl"
    // InternalMiniOCLCS.g:2625:1: rule__ConstraintsDefCS__Group__3__Impl : ( ( rule__ConstraintsDefCS__InvariantsAssignment_3 )* ) ;
    public final void rule__ConstraintsDefCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2629:1: ( ( ( rule__ConstraintsDefCS__InvariantsAssignment_3 )* ) )
            // InternalMiniOCLCS.g:2630:1: ( ( rule__ConstraintsDefCS__InvariantsAssignment_3 )* )
            {
            // InternalMiniOCLCS.g:2630:1: ( ( rule__ConstraintsDefCS__InvariantsAssignment_3 )* )
            // InternalMiniOCLCS.g:2631:2: ( rule__ConstraintsDefCS__InvariantsAssignment_3 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getInvariantsAssignment_3()); 
            }
            // InternalMiniOCLCS.g:2632:2: ( rule__ConstraintsDefCS__InvariantsAssignment_3 )*
            loop21:
            do {
                int alt21=2;
                int LA21_0 = input.LA(1);

                if ( (LA21_0==34) ) {
                    alt21=1;
                }


                switch (alt21) {
            	case 1 :
            	    // InternalMiniOCLCS.g:2632:3: rule__ConstraintsDefCS__InvariantsAssignment_3
            	    {
            	    pushFollow(FOLLOW_28);
            	    rule__ConstraintsDefCS__InvariantsAssignment_3();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getInvariantsAssignment_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__4"
    // InternalMiniOCLCS.g:2640:1: rule__ConstraintsDefCS__Group__4 : rule__ConstraintsDefCS__Group__4__Impl ;
    public final void rule__ConstraintsDefCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2644:1: ( rule__ConstraintsDefCS__Group__4__Impl )
            // InternalMiniOCLCS.g:2645:2: rule__ConstraintsDefCS__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__ConstraintsDefCS__Group__4__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__ConstraintsDefCS__Group__4__Impl"
    // InternalMiniOCLCS.g:2651:1: rule__ConstraintsDefCS__Group__4__Impl : ( '}' ) ;
    public final void rule__ConstraintsDefCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2655:1: ( ( '}' ) )
            // InternalMiniOCLCS.g:2656:1: ( '}' )
            {
            // InternalMiniOCLCS.g:2656:1: ( '}' )
            // InternalMiniOCLCS.g:2657:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getRightCurlyBracketKeyword_4()); 
            }
            match(input,22,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getRightCurlyBracketKeyword_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__0"
    // InternalMiniOCLCS.g:2667:1: rule__InvariantCS__Group__0 : rule__InvariantCS__Group__0__Impl rule__InvariantCS__Group__1 ;
    public final void rule__InvariantCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2671:1: ( rule__InvariantCS__Group__0__Impl rule__InvariantCS__Group__1 )
            // InternalMiniOCLCS.g:2672:2: rule__InvariantCS__Group__0__Impl rule__InvariantCS__Group__1
            {
            pushFollow(FOLLOW_9);
            rule__InvariantCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2679:1: rule__InvariantCS__Group__0__Impl : ( 'inv' ) ;
    public final void rule__InvariantCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2683:1: ( ( 'inv' ) )
            // InternalMiniOCLCS.g:2684:1: ( 'inv' )
            {
            // InternalMiniOCLCS.g:2684:1: ( 'inv' )
            // InternalMiniOCLCS.g:2685:2: 'inv'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getInvKeyword_0()); 
            }
            match(input,34,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvariantCSAccess().getInvKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__1"
    // InternalMiniOCLCS.g:2694:1: rule__InvariantCS__Group__1 : rule__InvariantCS__Group__1__Impl rule__InvariantCS__Group__2 ;
    public final void rule__InvariantCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2698:1: ( rule__InvariantCS__Group__1__Impl rule__InvariantCS__Group__2 )
            // InternalMiniOCLCS.g:2699:2: rule__InvariantCS__Group__1__Impl rule__InvariantCS__Group__2
            {
            pushFollow(FOLLOW_24);
            rule__InvariantCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2706:1: rule__InvariantCS__Group__1__Impl : ( ':' ) ;
    public final void rule__InvariantCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2710:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:2711:1: ( ':' )
            {
            // InternalMiniOCLCS.g:2711:1: ( ':' )
            // InternalMiniOCLCS.g:2712:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getColonKeyword_1()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvariantCSAccess().getColonKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__2"
    // InternalMiniOCLCS.g:2721:1: rule__InvariantCS__Group__2 : rule__InvariantCS__Group__2__Impl rule__InvariantCS__Group__3 ;
    public final void rule__InvariantCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2725:1: ( rule__InvariantCS__Group__2__Impl rule__InvariantCS__Group__3 )
            // InternalMiniOCLCS.g:2726:2: rule__InvariantCS__Group__2__Impl rule__InvariantCS__Group__3
            {
            pushFollow(FOLLOW_8);
            rule__InvariantCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__2__Impl"
    // InternalMiniOCLCS.g:2733:1: rule__InvariantCS__Group__2__Impl : ( ( rule__InvariantCS__ExpAssignment_2 ) ) ;
    public final void rule__InvariantCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2737:1: ( ( ( rule__InvariantCS__ExpAssignment_2 ) ) )
            // InternalMiniOCLCS.g:2738:1: ( ( rule__InvariantCS__ExpAssignment_2 ) )
            {
            // InternalMiniOCLCS.g:2738:1: ( ( rule__InvariantCS__ExpAssignment_2 ) )
            // InternalMiniOCLCS.g:2739:2: ( rule__InvariantCS__ExpAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getExpAssignment_2()); 
            }
            // InternalMiniOCLCS.g:2740:2: ( rule__InvariantCS__ExpAssignment_2 )
            // InternalMiniOCLCS.g:2740:3: rule__InvariantCS__ExpAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__InvariantCS__ExpAssignment_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvariantCSAccess().getExpAssignment_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__3"
    // InternalMiniOCLCS.g:2748:1: rule__InvariantCS__Group__3 : rule__InvariantCS__Group__3__Impl ;
    public final void rule__InvariantCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2752:1: ( rule__InvariantCS__Group__3__Impl )
            // InternalMiniOCLCS.g:2753:2: rule__InvariantCS__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__InvariantCS__Group__3__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__InvariantCS__Group__3__Impl"
    // InternalMiniOCLCS.g:2759:1: rule__InvariantCS__Group__3__Impl : ( ';' ) ;
    public final void rule__InvariantCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2763:1: ( ( ';' ) )
            // InternalMiniOCLCS.g:2764:1: ( ';' )
            {
            // InternalMiniOCLCS.g:2764:1: ( ';' )
            // InternalMiniOCLCS.g:2765:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getSemicolonKeyword_3()); 
            }
            match(input,18,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvariantCSAccess().getSemicolonKeyword_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group__0"
    // InternalMiniOCLCS.g:2775:1: rule__EqualityExpCS__Group__0 : rule__EqualityExpCS__Group__0__Impl rule__EqualityExpCS__Group__1 ;
    public final void rule__EqualityExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2779:1: ( rule__EqualityExpCS__Group__0__Impl rule__EqualityExpCS__Group__1 )
            // InternalMiniOCLCS.g:2780:2: rule__EqualityExpCS__Group__0__Impl rule__EqualityExpCS__Group__1
            {
            pushFollow(FOLLOW_29);
            rule__EqualityExpCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2787:1: rule__EqualityExpCS__Group__0__Impl : ( ruleCallExpCS ) ;
    public final void rule__EqualityExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2791:1: ( ( ruleCallExpCS ) )
            // InternalMiniOCLCS.g:2792:1: ( ruleCallExpCS )
            {
            // InternalMiniOCLCS.g:2792:1: ( ruleCallExpCS )
            // InternalMiniOCLCS.g:2793:2: ruleCallExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getCallExpCSParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCallExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group__1"
    // InternalMiniOCLCS.g:2802:1: rule__EqualityExpCS__Group__1 : rule__EqualityExpCS__Group__1__Impl ;
    public final void rule__EqualityExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2806:1: ( rule__EqualityExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:2807:2: rule__EqualityExpCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__Group__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2813:1: rule__EqualityExpCS__Group__1__Impl : ( ( rule__EqualityExpCS__Group_1__0 )* ) ;
    public final void rule__EqualityExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2817:1: ( ( ( rule__EqualityExpCS__Group_1__0 )* ) )
            // InternalMiniOCLCS.g:2818:1: ( ( rule__EqualityExpCS__Group_1__0 )* )
            {
            // InternalMiniOCLCS.g:2818:1: ( ( rule__EqualityExpCS__Group_1__0 )* )
            // InternalMiniOCLCS.g:2819:2: ( rule__EqualityExpCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:2820:2: ( rule__EqualityExpCS__Group_1__0 )*
            loop22:
            do {
                int alt22=2;
                int LA22_0 = input.LA(1);

                if ( (LA22_0==12) ) {
                    int LA22_2 = input.LA(2);

                    if ( (synpred28_InternalMiniOCLCS()) ) {
                        alt22=1;
                    }


                }
                else if ( (LA22_0==13) ) {
                    int LA22_3 = input.LA(2);

                    if ( (synpred28_InternalMiniOCLCS()) ) {
                        alt22=1;
                    }


                }


                switch (alt22) {
            	case 1 :
            	    // InternalMiniOCLCS.g:2820:3: rule__EqualityExpCS__Group_1__0
            	    {
            	    pushFollow(FOLLOW_30);
            	    rule__EqualityExpCS__Group_1__0();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getGroup_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group_1__0"
    // InternalMiniOCLCS.g:2829:1: rule__EqualityExpCS__Group_1__0 : rule__EqualityExpCS__Group_1__0__Impl rule__EqualityExpCS__Group_1__1 ;
    public final void rule__EqualityExpCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2833:1: ( rule__EqualityExpCS__Group_1__0__Impl rule__EqualityExpCS__Group_1__1 )
            // InternalMiniOCLCS.g:2834:2: rule__EqualityExpCS__Group_1__0__Impl rule__EqualityExpCS__Group_1__1
            {
            pushFollow(FOLLOW_29);
            rule__EqualityExpCS__Group_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:2841:1: rule__EqualityExpCS__Group_1__0__Impl : ( () ) ;
    public final void rule__EqualityExpCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2845:1: ( ( () ) )
            // InternalMiniOCLCS.g:2846:1: ( () )
            {
            // InternalMiniOCLCS.g:2846:1: ( () )
            // InternalMiniOCLCS.g:2847:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getEqualityExpCSLeftAction_1_0()); 
            }
            // InternalMiniOCLCS.g:2848:2: ()
            // InternalMiniOCLCS.g:2848:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getEqualityExpCSLeftAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group_1__1"
    // InternalMiniOCLCS.g:2856:1: rule__EqualityExpCS__Group_1__1 : rule__EqualityExpCS__Group_1__1__Impl rule__EqualityExpCS__Group_1__2 ;
    public final void rule__EqualityExpCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2860:1: ( rule__EqualityExpCS__Group_1__1__Impl rule__EqualityExpCS__Group_1__2 )
            // InternalMiniOCLCS.g:2861:2: rule__EqualityExpCS__Group_1__1__Impl rule__EqualityExpCS__Group_1__2
            {
            pushFollow(FOLLOW_24);
            rule__EqualityExpCS__Group_1__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:2868:1: rule__EqualityExpCS__Group_1__1__Impl : ( ( rule__EqualityExpCS__OpNameAssignment_1_1 ) ) ;
    public final void rule__EqualityExpCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2872:1: ( ( ( rule__EqualityExpCS__OpNameAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:2873:1: ( ( rule__EqualityExpCS__OpNameAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:2873:1: ( ( rule__EqualityExpCS__OpNameAssignment_1_1 ) )
            // InternalMiniOCLCS.g:2874:2: ( rule__EqualityExpCS__OpNameAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getOpNameAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:2875:2: ( rule__EqualityExpCS__OpNameAssignment_1_1 )
            // InternalMiniOCLCS.g:2875:3: rule__EqualityExpCS__OpNameAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__OpNameAssignment_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getOpNameAssignment_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EqualityExpCS__Group_1__2"
    // InternalMiniOCLCS.g:2883:1: rule__EqualityExpCS__Group_1__2 : rule__EqualityExpCS__Group_1__2__Impl ;
    public final void rule__EqualityExpCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2887:1: ( rule__EqualityExpCS__Group_1__2__Impl )
            // InternalMiniOCLCS.g:2888:2: rule__EqualityExpCS__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__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__EqualityExpCS__Group_1__2"


    // $ANTLR start "rule__EqualityExpCS__Group_1__2__Impl"
    // InternalMiniOCLCS.g:2894:1: rule__EqualityExpCS__Group_1__2__Impl : ( ( rule__EqualityExpCS__RightAssignment_1_2 ) ) ;
    public final void rule__EqualityExpCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2898:1: ( ( ( rule__EqualityExpCS__RightAssignment_1_2 ) ) )
            // InternalMiniOCLCS.g:2899:1: ( ( rule__EqualityExpCS__RightAssignment_1_2 ) )
            {
            // InternalMiniOCLCS.g:2899:1: ( ( rule__EqualityExpCS__RightAssignment_1_2 ) )
            // InternalMiniOCLCS.g:2900:2: ( rule__EqualityExpCS__RightAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getRightAssignment_1_2()); 
            }
            // InternalMiniOCLCS.g:2901:2: ( rule__EqualityExpCS__RightAssignment_1_2 )
            // InternalMiniOCLCS.g:2901:3: rule__EqualityExpCS__RightAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__RightAssignment_1_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getRightAssignment_1_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group__0"
    // InternalMiniOCLCS.g:2910:1: rule__CallExpCS__Group__0 : rule__CallExpCS__Group__0__Impl rule__CallExpCS__Group__1 ;
    public final void rule__CallExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2914:1: ( rule__CallExpCS__Group__0__Impl rule__CallExpCS__Group__1 )
            // InternalMiniOCLCS.g:2915:2: rule__CallExpCS__Group__0__Impl rule__CallExpCS__Group__1
            {
            pushFollow(FOLLOW_31);
            rule__CallExpCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group__0__Impl"
    // InternalMiniOCLCS.g:2922:1: rule__CallExpCS__Group__0__Impl : ( rulePrimaryExpCS ) ;
    public final void rule__CallExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2926:1: ( ( rulePrimaryExpCS ) )
            // InternalMiniOCLCS.g:2927:1: ( rulePrimaryExpCS )
            {
            // InternalMiniOCLCS.g:2927:1: ( rulePrimaryExpCS )
            // InternalMiniOCLCS.g:2928:2: rulePrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getPrimaryExpCSParserRuleCall_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePrimaryExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group__1"
    // InternalMiniOCLCS.g:2937:1: rule__CallExpCS__Group__1 : rule__CallExpCS__Group__1__Impl ;
    public final void rule__CallExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2941:1: ( rule__CallExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:2942:2: rule__CallExpCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__Group__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:2948:1: rule__CallExpCS__Group__1__Impl : ( ( rule__CallExpCS__Group_1__0 )* ) ;
    public final void rule__CallExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2952:1: ( ( ( rule__CallExpCS__Group_1__0 )* ) )
            // InternalMiniOCLCS.g:2953:1: ( ( rule__CallExpCS__Group_1__0 )* )
            {
            // InternalMiniOCLCS.g:2953:1: ( ( rule__CallExpCS__Group_1__0 )* )
            // InternalMiniOCLCS.g:2954:2: ( rule__CallExpCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:2955:2: ( rule__CallExpCS__Group_1__0 )*
            loop23:
            do {
                int alt23=2;
                int LA23_0 = input.LA(1);

                if ( (LA23_0==14) ) {
                    int LA23_2 = input.LA(2);

                    if ( (synpred29_InternalMiniOCLCS()) ) {
                        alt23=1;
                    }


                }
                else if ( (LA23_0==15) ) {
                    int LA23_3 = input.LA(2);

                    if ( (synpred29_InternalMiniOCLCS()) ) {
                        alt23=1;
                    }


                }


                switch (alt23) {
            	case 1 :
            	    // InternalMiniOCLCS.g:2955:3: rule__CallExpCS__Group_1__0
            	    {
            	    pushFollow(FOLLOW_32);
            	    rule__CallExpCS__Group_1__0();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getGroup_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group_1__0"
    // InternalMiniOCLCS.g:2964:1: rule__CallExpCS__Group_1__0 : rule__CallExpCS__Group_1__0__Impl rule__CallExpCS__Group_1__1 ;
    public final void rule__CallExpCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2968:1: ( rule__CallExpCS__Group_1__0__Impl rule__CallExpCS__Group_1__1 )
            // InternalMiniOCLCS.g:2969:2: rule__CallExpCS__Group_1__0__Impl rule__CallExpCS__Group_1__1
            {
            pushFollow(FOLLOW_31);
            rule__CallExpCS__Group_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:2976:1: rule__CallExpCS__Group_1__0__Impl : ( () ) ;
    public final void rule__CallExpCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2980:1: ( ( () ) )
            // InternalMiniOCLCS.g:2981:1: ( () )
            {
            // InternalMiniOCLCS.g:2981:1: ( () )
            // InternalMiniOCLCS.g:2982:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getCallExpCSSourceAction_1_0()); 
            }
            // InternalMiniOCLCS.g:2983:2: ()
            // InternalMiniOCLCS.g:2983:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getCallExpCSSourceAction_1_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group_1__1"
    // InternalMiniOCLCS.g:2991:1: rule__CallExpCS__Group_1__1 : rule__CallExpCS__Group_1__1__Impl rule__CallExpCS__Group_1__2 ;
    public final void rule__CallExpCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:2995:1: ( rule__CallExpCS__Group_1__1__Impl rule__CallExpCS__Group_1__2 )
            // InternalMiniOCLCS.g:2996:2: rule__CallExpCS__Group_1__1__Impl rule__CallExpCS__Group_1__2
            {
            pushFollow(FOLLOW_33);
            rule__CallExpCS__Group_1__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:3003:1: rule__CallExpCS__Group_1__1__Impl : ( ( rule__CallExpCS__OpNameAssignment_1_1 ) ) ;
    public final void rule__CallExpCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3007:1: ( ( ( rule__CallExpCS__OpNameAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:3008:1: ( ( rule__CallExpCS__OpNameAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:3008:1: ( ( rule__CallExpCS__OpNameAssignment_1_1 ) )
            // InternalMiniOCLCS.g:3009:2: ( rule__CallExpCS__OpNameAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getOpNameAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:3010:2: ( rule__CallExpCS__OpNameAssignment_1_1 )
            // InternalMiniOCLCS.g:3010:3: rule__CallExpCS__OpNameAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__OpNameAssignment_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getOpNameAssignment_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CallExpCS__Group_1__2"
    // InternalMiniOCLCS.g:3018:1: rule__CallExpCS__Group_1__2 : rule__CallExpCS__Group_1__2__Impl ;
    public final void rule__CallExpCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3022:1: ( rule__CallExpCS__Group_1__2__Impl )
            // InternalMiniOCLCS.g:3023:2: rule__CallExpCS__Group_1__2__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__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__CallExpCS__Group_1__2"


    // $ANTLR start "rule__CallExpCS__Group_1__2__Impl"
    // InternalMiniOCLCS.g:3029:1: rule__CallExpCS__Group_1__2__Impl : ( ( rule__CallExpCS__NavExpAssignment_1_2 ) ) ;
    public final void rule__CallExpCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3033:1: ( ( ( rule__CallExpCS__NavExpAssignment_1_2 ) ) )
            // InternalMiniOCLCS.g:3034:1: ( ( rule__CallExpCS__NavExpAssignment_1_2 ) )
            {
            // InternalMiniOCLCS.g:3034:1: ( ( rule__CallExpCS__NavExpAssignment_1_2 ) )
            // InternalMiniOCLCS.g:3035:2: ( rule__CallExpCS__NavExpAssignment_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getNavExpAssignment_1_2()); 
            }
            // InternalMiniOCLCS.g:3036:2: ( rule__CallExpCS__NavExpAssignment_1_2 )
            // InternalMiniOCLCS.g:3036:3: rule__CallExpCS__NavExpAssignment_1_2
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__NavExpAssignment_1_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getNavExpAssignment_1_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__SelfExpCS__Group__0"
    // InternalMiniOCLCS.g:3045: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 {
            // InternalMiniOCLCS.g:3049:1: ( rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 )
            // InternalMiniOCLCS.g:3050:2: rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1
            {
            pushFollow(FOLLOW_34);
            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"
    // InternalMiniOCLCS.g:3057:1: rule__SelfExpCS__Group__0__Impl : ( () ) ;
    public final void rule__SelfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3061:1: ( ( () ) )
            // InternalMiniOCLCS.g:3062:1: ( () )
            {
            // InternalMiniOCLCS.g:3062:1: ( () )
            // InternalMiniOCLCS.g:3063:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0()); 
            }
            // InternalMiniOCLCS.g:3064:2: ()
            // InternalMiniOCLCS.g:3064: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"
    // InternalMiniOCLCS.g:3072:1: rule__SelfExpCS__Group__1 : rule__SelfExpCS__Group__1__Impl ;
    public final void rule__SelfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3076:1: ( rule__SelfExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:3077: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"
    // InternalMiniOCLCS.g:3083:1: rule__SelfExpCS__Group__1__Impl : ( 'self' ) ;
    public final void rule__SelfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3087:1: ( ( 'self' ) )
            // InternalMiniOCLCS.g:3088:1: ( 'self' )
            {
            // InternalMiniOCLCS.g:3088:1: ( 'self' )
            // InternalMiniOCLCS.g:3089:2: 'self'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1()); 
            }
            match(input,35,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__CollectExpCS__Group__0"
    // InternalMiniOCLCS.g:3099:1: rule__CollectExpCS__Group__0 : rule__CollectExpCS__Group__0__Impl rule__CollectExpCS__Group__1 ;
    public final void rule__CollectExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3103:1: ( rule__CollectExpCS__Group__0__Impl rule__CollectExpCS__Group__1 )
            // InternalMiniOCLCS.g:3104:2: rule__CollectExpCS__Group__0__Impl rule__CollectExpCS__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__CollectExpCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__0__Impl"
    // InternalMiniOCLCS.g:3111:1: rule__CollectExpCS__Group__0__Impl : ( 'collect' ) ;
    public final void rule__CollectExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3115:1: ( ( 'collect' ) )
            // InternalMiniOCLCS.g:3116:1: ( 'collect' )
            {
            // InternalMiniOCLCS.g:3116:1: ( 'collect' )
            // InternalMiniOCLCS.g:3117:2: 'collect'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getCollectKeyword_0()); 
            }
            match(input,36,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getCollectKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__1"
    // InternalMiniOCLCS.g:3126:1: rule__CollectExpCS__Group__1 : rule__CollectExpCS__Group__1__Impl rule__CollectExpCS__Group__2 ;
    public final void rule__CollectExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3130:1: ( rule__CollectExpCS__Group__1__Impl rule__CollectExpCS__Group__2 )
            // InternalMiniOCLCS.g:3131:2: rule__CollectExpCS__Group__1__Impl rule__CollectExpCS__Group__2
            {
            pushFollow(FOLLOW_24);
            rule__CollectExpCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3138:1: rule__CollectExpCS__Group__1__Impl : ( '(' ) ;
    public final void rule__CollectExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3142:1: ( ( '(' ) )
            // InternalMiniOCLCS.g:3143:1: ( '(' )
            {
            // InternalMiniOCLCS.g:3143:1: ( '(' )
            // InternalMiniOCLCS.g:3144:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getLeftParenthesisKeyword_1()); 
            }
            match(input,30,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getLeftParenthesisKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__2"
    // InternalMiniOCLCS.g:3153:1: rule__CollectExpCS__Group__2 : rule__CollectExpCS__Group__2__Impl rule__CollectExpCS__Group__3 ;
    public final void rule__CollectExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3157:1: ( rule__CollectExpCS__Group__2__Impl rule__CollectExpCS__Group__3 )
            // InternalMiniOCLCS.g:3158:2: rule__CollectExpCS__Group__2__Impl rule__CollectExpCS__Group__3
            {
            pushFollow(FOLLOW_24);
            rule__CollectExpCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__2__Impl"
    // InternalMiniOCLCS.g:3165:1: rule__CollectExpCS__Group__2__Impl : ( ( rule__CollectExpCS__Group_2__0 )? ) ;
    public final void rule__CollectExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3169:1: ( ( ( rule__CollectExpCS__Group_2__0 )? ) )
            // InternalMiniOCLCS.g:3170:1: ( ( rule__CollectExpCS__Group_2__0 )? )
            {
            // InternalMiniOCLCS.g:3170:1: ( ( rule__CollectExpCS__Group_2__0 )? )
            // InternalMiniOCLCS.g:3171:2: ( rule__CollectExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getGroup_2()); 
            }
            // InternalMiniOCLCS.g:3172:2: ( rule__CollectExpCS__Group_2__0 )?
            int alt24=2;
            int LA24_0 = input.LA(1);

            if ( (LA24_0==RULE_ID) ) {
                int LA24_1 = input.LA(2);

                if ( (LA24_1==19||LA24_1==37) ) {
                    alt24=1;
                }
            }
            switch (alt24) {
                case 1 :
                    // InternalMiniOCLCS.g:3172:3: rule__CollectExpCS__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CollectExpCS__Group_2__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getGroup_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__3"
    // InternalMiniOCLCS.g:3180:1: rule__CollectExpCS__Group__3 : rule__CollectExpCS__Group__3__Impl rule__CollectExpCS__Group__4 ;
    public final void rule__CollectExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3184:1: ( rule__CollectExpCS__Group__3__Impl rule__CollectExpCS__Group__4 )
            // InternalMiniOCLCS.g:3185:2: rule__CollectExpCS__Group__3__Impl rule__CollectExpCS__Group__4
            {
            pushFollow(FOLLOW_35);
            rule__CollectExpCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__3__Impl"
    // InternalMiniOCLCS.g:3192:1: rule__CollectExpCS__Group__3__Impl : ( ( rule__CollectExpCS__ExpAssignment_3 ) ) ;
    public final void rule__CollectExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3196:1: ( ( ( rule__CollectExpCS__ExpAssignment_3 ) ) )
            // InternalMiniOCLCS.g:3197:1: ( ( rule__CollectExpCS__ExpAssignment_3 ) )
            {
            // InternalMiniOCLCS.g:3197:1: ( ( rule__CollectExpCS__ExpAssignment_3 ) )
            // InternalMiniOCLCS.g:3198:2: ( rule__CollectExpCS__ExpAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getExpAssignment_3()); 
            }
            // InternalMiniOCLCS.g:3199:2: ( rule__CollectExpCS__ExpAssignment_3 )
            // InternalMiniOCLCS.g:3199:3: rule__CollectExpCS__ExpAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__CollectExpCS__ExpAssignment_3();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getExpAssignment_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__4"
    // InternalMiniOCLCS.g:3207:1: rule__CollectExpCS__Group__4 : rule__CollectExpCS__Group__4__Impl ;
    public final void rule__CollectExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3211:1: ( rule__CollectExpCS__Group__4__Impl )
            // InternalMiniOCLCS.g:3212:2: rule__CollectExpCS__Group__4__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CollectExpCS__Group__4__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group__4__Impl"
    // InternalMiniOCLCS.g:3218:1: rule__CollectExpCS__Group__4__Impl : ( ')' ) ;
    public final void rule__CollectExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3222:1: ( ( ')' ) )
            // InternalMiniOCLCS.g:3223:1: ( ')' )
            {
            // InternalMiniOCLCS.g:3223:1: ( ')' )
            // InternalMiniOCLCS.g:3224:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getRightParenthesisKeyword_4()); 
            }
            match(input,31,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getRightParenthesisKeyword_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group_2__0"
    // InternalMiniOCLCS.g:3234:1: rule__CollectExpCS__Group_2__0 : rule__CollectExpCS__Group_2__0__Impl rule__CollectExpCS__Group_2__1 ;
    public final void rule__CollectExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3238:1: ( rule__CollectExpCS__Group_2__0__Impl rule__CollectExpCS__Group_2__1 )
            // InternalMiniOCLCS.g:3239:2: rule__CollectExpCS__Group_2__0__Impl rule__CollectExpCS__Group_2__1
            {
            pushFollow(FOLLOW_36);
            rule__CollectExpCS__Group_2__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group_2__0__Impl"
    // InternalMiniOCLCS.g:3246:1: rule__CollectExpCS__Group_2__0__Impl : ( ( rule__CollectExpCS__ItVarAssignment_2_0 ) ) ;
    public final void rule__CollectExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3250:1: ( ( ( rule__CollectExpCS__ItVarAssignment_2_0 ) ) )
            // InternalMiniOCLCS.g:3251:1: ( ( rule__CollectExpCS__ItVarAssignment_2_0 ) )
            {
            // InternalMiniOCLCS.g:3251:1: ( ( rule__CollectExpCS__ItVarAssignment_2_0 ) )
            // InternalMiniOCLCS.g:3252:2: ( rule__CollectExpCS__ItVarAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getItVarAssignment_2_0()); 
            }
            // InternalMiniOCLCS.g:3253:2: ( rule__CollectExpCS__ItVarAssignment_2_0 )
            // InternalMiniOCLCS.g:3253:3: rule__CollectExpCS__ItVarAssignment_2_0
            {
            pushFollow(FOLLOW_2);
            rule__CollectExpCS__ItVarAssignment_2_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getItVarAssignment_2_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__CollectExpCS__Group_2__1"
    // InternalMiniOCLCS.g:3261:1: rule__CollectExpCS__Group_2__1 : rule__CollectExpCS__Group_2__1__Impl ;
    public final void rule__CollectExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3265:1: ( rule__CollectExpCS__Group_2__1__Impl )
            // InternalMiniOCLCS.g:3266:2: rule__CollectExpCS__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CollectExpCS__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__CollectExpCS__Group_2__1"


    // $ANTLR start "rule__CollectExpCS__Group_2__1__Impl"
    // InternalMiniOCLCS.g:3272:1: rule__CollectExpCS__Group_2__1__Impl : ( '|' ) ;
    public final void rule__CollectExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3276:1: ( ( '|' ) )
            // InternalMiniOCLCS.g:3277:1: ( '|' )
            {
            // InternalMiniOCLCS.g:3277:1: ( '|' )
            // InternalMiniOCLCS.g:3278:2: '|'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getVerticalLineKeyword_2_1()); 
            }
            match(input,37,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getVerticalLineKeyword_2_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group__0"
    // InternalMiniOCLCS.g:3288:1: rule__IteratorVarCS__Group__0 : rule__IteratorVarCS__Group__0__Impl rule__IteratorVarCS__Group__1 ;
    public final void rule__IteratorVarCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3292:1: ( rule__IteratorVarCS__Group__0__Impl rule__IteratorVarCS__Group__1 )
            // InternalMiniOCLCS.g:3293:2: rule__IteratorVarCS__Group__0__Impl rule__IteratorVarCS__Group__1
            {
            pushFollow(FOLLOW_9);
            rule__IteratorVarCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group__0__Impl"
    // InternalMiniOCLCS.g:3300:1: rule__IteratorVarCS__Group__0__Impl : ( ( rule__IteratorVarCS__ItNameAssignment_0 ) ) ;
    public final void rule__IteratorVarCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3304:1: ( ( ( rule__IteratorVarCS__ItNameAssignment_0 ) ) )
            // InternalMiniOCLCS.g:3305:1: ( ( rule__IteratorVarCS__ItNameAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:3305:1: ( ( rule__IteratorVarCS__ItNameAssignment_0 ) )
            // InternalMiniOCLCS.g:3306:2: ( rule__IteratorVarCS__ItNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getItNameAssignment_0()); 
            }
            // InternalMiniOCLCS.g:3307:2: ( rule__IteratorVarCS__ItNameAssignment_0 )
            // InternalMiniOCLCS.g:3307:3: rule__IteratorVarCS__ItNameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__IteratorVarCS__ItNameAssignment_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getItNameAssignment_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group__1"
    // InternalMiniOCLCS.g:3315:1: rule__IteratorVarCS__Group__1 : rule__IteratorVarCS__Group__1__Impl ;
    public final void rule__IteratorVarCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3319:1: ( rule__IteratorVarCS__Group__1__Impl )
            // InternalMiniOCLCS.g:3320:2: rule__IteratorVarCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__IteratorVarCS__Group__1__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3326:1: rule__IteratorVarCS__Group__1__Impl : ( ( rule__IteratorVarCS__Group_1__0 )? ) ;
    public final void rule__IteratorVarCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3330:1: ( ( ( rule__IteratorVarCS__Group_1__0 )? ) )
            // InternalMiniOCLCS.g:3331:1: ( ( rule__IteratorVarCS__Group_1__0 )? )
            {
            // InternalMiniOCLCS.g:3331:1: ( ( rule__IteratorVarCS__Group_1__0 )? )
            // InternalMiniOCLCS.g:3332:2: ( rule__IteratorVarCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:3333:2: ( rule__IteratorVarCS__Group_1__0 )?
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( (LA25_0==19) ) {
                alt25=1;
            }
            switch (alt25) {
                case 1 :
                    // InternalMiniOCLCS.g:3333:3: rule__IteratorVarCS__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__IteratorVarCS__Group_1__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getGroup_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group_1__0"
    // InternalMiniOCLCS.g:3342:1: rule__IteratorVarCS__Group_1__0 : rule__IteratorVarCS__Group_1__0__Impl rule__IteratorVarCS__Group_1__1 ;
    public final void rule__IteratorVarCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3346:1: ( rule__IteratorVarCS__Group_1__0__Impl rule__IteratorVarCS__Group_1__1 )
            // InternalMiniOCLCS.g:3347:2: rule__IteratorVarCS__Group_1__0__Impl rule__IteratorVarCS__Group_1__1
            {
            pushFollow(FOLLOW_6);
            rule__IteratorVarCS__Group_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:3354:1: rule__IteratorVarCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__IteratorVarCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3358:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:3359:1: ( ':' )
            {
            // InternalMiniOCLCS.g:3359:1: ( ':' )
            // InternalMiniOCLCS.g:3360:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getColonKeyword_1_0()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getColonKeyword_1_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IteratorVarCS__Group_1__1"
    // InternalMiniOCLCS.g:3369:1: rule__IteratorVarCS__Group_1__1 : rule__IteratorVarCS__Group_1__1__Impl ;
    public final void rule__IteratorVarCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3373:1: ( rule__IteratorVarCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:3374:2: rule__IteratorVarCS__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__IteratorVarCS__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__IteratorVarCS__Group_1__1"


    // $ANTLR start "rule__IteratorVarCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:3380:1: rule__IteratorVarCS__Group_1__1__Impl : ( ( rule__IteratorVarCS__ItTypeAssignment_1_1 ) ) ;
    public final void rule__IteratorVarCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3384:1: ( ( ( rule__IteratorVarCS__ItTypeAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:3385:1: ( ( rule__IteratorVarCS__ItTypeAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:3385:1: ( ( rule__IteratorVarCS__ItTypeAssignment_1_1 ) )
            // InternalMiniOCLCS.g:3386:2: ( rule__IteratorVarCS__ItTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getItTypeAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:3387:2: ( rule__IteratorVarCS__ItTypeAssignment_1_1 )
            // InternalMiniOCLCS.g:3387:3: rule__IteratorVarCS__ItTypeAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__IteratorVarCS__ItTypeAssignment_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getItTypeAssignment_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__0"
    // InternalMiniOCLCS.g:3396:1: rule__IterateExpCS__Group__0 : rule__IterateExpCS__Group__0__Impl rule__IterateExpCS__Group__1 ;
    public final void rule__IterateExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3400:1: ( rule__IterateExpCS__Group__0__Impl rule__IterateExpCS__Group__1 )
            // InternalMiniOCLCS.g:3401:2: rule__IterateExpCS__Group__0__Impl rule__IterateExpCS__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__IterateExpCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__0__Impl"
    // InternalMiniOCLCS.g:3408:1: rule__IterateExpCS__Group__0__Impl : ( 'iterate' ) ;
    public final void rule__IterateExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3412:1: ( ( 'iterate' ) )
            // InternalMiniOCLCS.g:3413:1: ( 'iterate' )
            {
            // InternalMiniOCLCS.g:3413:1: ( 'iterate' )
            // InternalMiniOCLCS.g:3414:2: 'iterate'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getIterateKeyword_0()); 
            }
            match(input,38,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getIterateKeyword_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__1"
    // InternalMiniOCLCS.g:3423:1: rule__IterateExpCS__Group__1 : rule__IterateExpCS__Group__1__Impl rule__IterateExpCS__Group__2 ;
    public final void rule__IterateExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3427:1: ( rule__IterateExpCS__Group__1__Impl rule__IterateExpCS__Group__2 )
            // InternalMiniOCLCS.g:3428:2: rule__IterateExpCS__Group__1__Impl rule__IterateExpCS__Group__2
            {
            pushFollow(FOLLOW_6);
            rule__IterateExpCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3435:1: rule__IterateExpCS__Group__1__Impl : ( '(' ) ;
    public final void rule__IterateExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3439:1: ( ( '(' ) )
            // InternalMiniOCLCS.g:3440:1: ( '(' )
            {
            // InternalMiniOCLCS.g:3440:1: ( '(' )
            // InternalMiniOCLCS.g:3441:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getLeftParenthesisKeyword_1()); 
            }
            match(input,30,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getLeftParenthesisKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__2"
    // InternalMiniOCLCS.g:3450:1: rule__IterateExpCS__Group__2 : rule__IterateExpCS__Group__2__Impl rule__IterateExpCS__Group__3 ;
    public final void rule__IterateExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3454:1: ( rule__IterateExpCS__Group__2__Impl rule__IterateExpCS__Group__3 )
            // InternalMiniOCLCS.g:3455:2: rule__IterateExpCS__Group__2__Impl rule__IterateExpCS__Group__3
            {
            pushFollow(FOLLOW_8);
            rule__IterateExpCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__2__Impl"
    // InternalMiniOCLCS.g:3462:1: rule__IterateExpCS__Group__2__Impl : ( ( rule__IterateExpCS__ItVarAssignment_2 ) ) ;
    public final void rule__IterateExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3466:1: ( ( ( rule__IterateExpCS__ItVarAssignment_2 ) ) )
            // InternalMiniOCLCS.g:3467:1: ( ( rule__IterateExpCS__ItVarAssignment_2 ) )
            {
            // InternalMiniOCLCS.g:3467:1: ( ( rule__IterateExpCS__ItVarAssignment_2 ) )
            // InternalMiniOCLCS.g:3468:2: ( rule__IterateExpCS__ItVarAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getItVarAssignment_2()); 
            }
            // InternalMiniOCLCS.g:3469:2: ( rule__IterateExpCS__ItVarAssignment_2 )
            // InternalMiniOCLCS.g:3469:3: rule__IterateExpCS__ItVarAssignment_2
            {
            pushFollow(FOLLOW_2);
            rule__IterateExpCS__ItVarAssignment_2();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getItVarAssignment_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__3"
    // InternalMiniOCLCS.g:3477:1: rule__IterateExpCS__Group__3 : rule__IterateExpCS__Group__3__Impl rule__IterateExpCS__Group__4 ;
    public final void rule__IterateExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3481:1: ( rule__IterateExpCS__Group__3__Impl rule__IterateExpCS__Group__4 )
            // InternalMiniOCLCS.g:3482:2: rule__IterateExpCS__Group__3__Impl rule__IterateExpCS__Group__4
            {
            pushFollow(FOLLOW_6);
            rule__IterateExpCS__Group__3__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__3__Impl"
    // InternalMiniOCLCS.g:3489:1: rule__IterateExpCS__Group__3__Impl : ( ';' ) ;
    public final void rule__IterateExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3493:1: ( ( ';' ) )
            // InternalMiniOCLCS.g:3494:1: ( ';' )
            {
            // InternalMiniOCLCS.g:3494:1: ( ';' )
            // InternalMiniOCLCS.g:3495:2: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getSemicolonKeyword_3()); 
            }
            match(input,18,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getSemicolonKeyword_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__4"
    // InternalMiniOCLCS.g:3504:1: rule__IterateExpCS__Group__4 : rule__IterateExpCS__Group__4__Impl rule__IterateExpCS__Group__5 ;
    public final void rule__IterateExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3508:1: ( rule__IterateExpCS__Group__4__Impl rule__IterateExpCS__Group__5 )
            // InternalMiniOCLCS.g:3509:2: rule__IterateExpCS__Group__4__Impl rule__IterateExpCS__Group__5
            {
            pushFollow(FOLLOW_36);
            rule__IterateExpCS__Group__4__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__4__Impl"
    // InternalMiniOCLCS.g:3516:1: rule__IterateExpCS__Group__4__Impl : ( ( rule__IterateExpCS__AccVarAssignment_4 ) ) ;
    public final void rule__IterateExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3520:1: ( ( ( rule__IterateExpCS__AccVarAssignment_4 ) ) )
            // InternalMiniOCLCS.g:3521:1: ( ( rule__IterateExpCS__AccVarAssignment_4 ) )
            {
            // InternalMiniOCLCS.g:3521:1: ( ( rule__IterateExpCS__AccVarAssignment_4 ) )
            // InternalMiniOCLCS.g:3522:2: ( rule__IterateExpCS__AccVarAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getAccVarAssignment_4()); 
            }
            // InternalMiniOCLCS.g:3523:2: ( rule__IterateExpCS__AccVarAssignment_4 )
            // InternalMiniOCLCS.g:3523:3: rule__IterateExpCS__AccVarAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__IterateExpCS__AccVarAssignment_4();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getAccVarAssignment_4()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__5"
    // InternalMiniOCLCS.g:3531:1: rule__IterateExpCS__Group__5 : rule__IterateExpCS__Group__5__Impl rule__IterateExpCS__Group__6 ;
    public final void rule__IterateExpCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3535:1: ( rule__IterateExpCS__Group__5__Impl rule__IterateExpCS__Group__6 )
            // InternalMiniOCLCS.g:3536:2: rule__IterateExpCS__Group__5__Impl rule__IterateExpCS__Group__6
            {
            pushFollow(FOLLOW_24);
            rule__IterateExpCS__Group__5__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__5__Impl"
    // InternalMiniOCLCS.g:3543:1: rule__IterateExpCS__Group__5__Impl : ( '|' ) ;
    public final void rule__IterateExpCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3547:1: ( ( '|' ) )
            // InternalMiniOCLCS.g:3548:1: ( '|' )
            {
            // InternalMiniOCLCS.g:3548:1: ( '|' )
            // InternalMiniOCLCS.g:3549:2: '|'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getVerticalLineKeyword_5()); 
            }
            match(input,37,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getVerticalLineKeyword_5()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__6"
    // InternalMiniOCLCS.g:3558:1: rule__IterateExpCS__Group__6 : rule__IterateExpCS__Group__6__Impl rule__IterateExpCS__Group__7 ;
    public final void rule__IterateExpCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3562:1: ( rule__IterateExpCS__Group__6__Impl rule__IterateExpCS__Group__7 )
            // InternalMiniOCLCS.g:3563:2: rule__IterateExpCS__Group__6__Impl rule__IterateExpCS__Group__7
            {
            pushFollow(FOLLOW_35);
            rule__IterateExpCS__Group__6__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__6__Impl"
    // InternalMiniOCLCS.g:3570:1: rule__IterateExpCS__Group__6__Impl : ( ( rule__IterateExpCS__ExpAssignment_6 ) ) ;
    public final void rule__IterateExpCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3574:1: ( ( ( rule__IterateExpCS__ExpAssignment_6 ) ) )
            // InternalMiniOCLCS.g:3575:1: ( ( rule__IterateExpCS__ExpAssignment_6 ) )
            {
            // InternalMiniOCLCS.g:3575:1: ( ( rule__IterateExpCS__ExpAssignment_6 ) )
            // InternalMiniOCLCS.g:3576:2: ( rule__IterateExpCS__ExpAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getExpAssignment_6()); 
            }
            // InternalMiniOCLCS.g:3577:2: ( rule__IterateExpCS__ExpAssignment_6 )
            // InternalMiniOCLCS.g:3577:3: rule__IterateExpCS__ExpAssignment_6
            {
            pushFollow(FOLLOW_2);
            rule__IterateExpCS__ExpAssignment_6();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getExpAssignment_6()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__7"
    // InternalMiniOCLCS.g:3585:1: rule__IterateExpCS__Group__7 : rule__IterateExpCS__Group__7__Impl ;
    public final void rule__IterateExpCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3589:1: ( rule__IterateExpCS__Group__7__Impl )
            // InternalMiniOCLCS.g:3590:2: rule__IterateExpCS__Group__7__Impl
            {
            pushFollow(FOLLOW_2);
            rule__IterateExpCS__Group__7__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__IterateExpCS__Group__7__Impl"
    // InternalMiniOCLCS.g:3596:1: rule__IterateExpCS__Group__7__Impl : ( ')' ) ;
    public final void rule__IterateExpCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3600:1: ( ( ')' ) )
            // InternalMiniOCLCS.g:3601:1: ( ')' )
            {
            // InternalMiniOCLCS.g:3601:1: ( ')' )
            // InternalMiniOCLCS.g:3602:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getRightParenthesisKeyword_7()); 
            }
            match(input,31,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getRightParenthesisKeyword_7()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__0"
    // InternalMiniOCLCS.g:3612:1: rule__AccVarCS__Group__0 : rule__AccVarCS__Group__0__Impl rule__AccVarCS__Group__1 ;
    public final void rule__AccVarCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3616:1: ( rule__AccVarCS__Group__0__Impl rule__AccVarCS__Group__1 )
            // InternalMiniOCLCS.g:3617:2: rule__AccVarCS__Group__0__Impl rule__AccVarCS__Group__1
            {
            pushFollow(FOLLOW_37);
            rule__AccVarCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__0__Impl"
    // InternalMiniOCLCS.g:3624:1: rule__AccVarCS__Group__0__Impl : ( ( rule__AccVarCS__AccNameAssignment_0 ) ) ;
    public final void rule__AccVarCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3628:1: ( ( ( rule__AccVarCS__AccNameAssignment_0 ) ) )
            // InternalMiniOCLCS.g:3629:1: ( ( rule__AccVarCS__AccNameAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:3629:1: ( ( rule__AccVarCS__AccNameAssignment_0 ) )
            // InternalMiniOCLCS.g:3630:2: ( rule__AccVarCS__AccNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccNameAssignment_0()); 
            }
            // InternalMiniOCLCS.g:3631:2: ( rule__AccVarCS__AccNameAssignment_0 )
            // InternalMiniOCLCS.g:3631:3: rule__AccVarCS__AccNameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__AccNameAssignment_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccNameAssignment_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__1"
    // InternalMiniOCLCS.g:3639:1: rule__AccVarCS__Group__1 : rule__AccVarCS__Group__1__Impl rule__AccVarCS__Group__2 ;
    public final void rule__AccVarCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3643:1: ( rule__AccVarCS__Group__1__Impl rule__AccVarCS__Group__2 )
            // InternalMiniOCLCS.g:3644:2: rule__AccVarCS__Group__1__Impl rule__AccVarCS__Group__2
            {
            pushFollow(FOLLOW_37);
            rule__AccVarCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3651:1: rule__AccVarCS__Group__1__Impl : ( ( rule__AccVarCS__Group_1__0 )? ) ;
    public final void rule__AccVarCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3655:1: ( ( ( rule__AccVarCS__Group_1__0 )? ) )
            // InternalMiniOCLCS.g:3656:1: ( ( rule__AccVarCS__Group_1__0 )? )
            {
            // InternalMiniOCLCS.g:3656:1: ( ( rule__AccVarCS__Group_1__0 )? )
            // InternalMiniOCLCS.g:3657:2: ( rule__AccVarCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:3658:2: ( rule__AccVarCS__Group_1__0 )?
            int alt26=2;
            int LA26_0 = input.LA(1);

            if ( (LA26_0==19) ) {
                alt26=1;
            }
            switch (alt26) {
                case 1 :
                    // InternalMiniOCLCS.g:3658:3: rule__AccVarCS__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__AccVarCS__Group_1__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getGroup_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__2"
    // InternalMiniOCLCS.g:3666:1: rule__AccVarCS__Group__2 : rule__AccVarCS__Group__2__Impl rule__AccVarCS__Group__3 ;
    public final void rule__AccVarCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3670:1: ( rule__AccVarCS__Group__2__Impl rule__AccVarCS__Group__3 )
            // InternalMiniOCLCS.g:3671:2: rule__AccVarCS__Group__2__Impl rule__AccVarCS__Group__3
            {
            pushFollow(FOLLOW_24);
            rule__AccVarCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__2__Impl"
    // InternalMiniOCLCS.g:3678:1: rule__AccVarCS__Group__2__Impl : ( '=' ) ;
    public final void rule__AccVarCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3682:1: ( ( '=' ) )
            // InternalMiniOCLCS.g:3683:1: ( '=' )
            {
            // InternalMiniOCLCS.g:3683:1: ( '=' )
            // InternalMiniOCLCS.g:3684:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getEqualsSignKeyword_2()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getEqualsSignKeyword_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__3"
    // InternalMiniOCLCS.g:3693:1: rule__AccVarCS__Group__3 : rule__AccVarCS__Group__3__Impl ;
    public final void rule__AccVarCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3697:1: ( rule__AccVarCS__Group__3__Impl )
            // InternalMiniOCLCS.g:3698:2: rule__AccVarCS__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__Group__3__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group__3__Impl"
    // InternalMiniOCLCS.g:3704:1: rule__AccVarCS__Group__3__Impl : ( ( rule__AccVarCS__AccInitExpAssignment_3 ) ) ;
    public final void rule__AccVarCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3708:1: ( ( ( rule__AccVarCS__AccInitExpAssignment_3 ) ) )
            // InternalMiniOCLCS.g:3709:1: ( ( rule__AccVarCS__AccInitExpAssignment_3 ) )
            {
            // InternalMiniOCLCS.g:3709:1: ( ( rule__AccVarCS__AccInitExpAssignment_3 ) )
            // InternalMiniOCLCS.g:3710:2: ( rule__AccVarCS__AccInitExpAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccInitExpAssignment_3()); 
            }
            // InternalMiniOCLCS.g:3711:2: ( rule__AccVarCS__AccInitExpAssignment_3 )
            // InternalMiniOCLCS.g:3711:3: rule__AccVarCS__AccInitExpAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__AccInitExpAssignment_3();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccInitExpAssignment_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group_1__0"
    // InternalMiniOCLCS.g:3720:1: rule__AccVarCS__Group_1__0 : rule__AccVarCS__Group_1__0__Impl rule__AccVarCS__Group_1__1 ;
    public final void rule__AccVarCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3724:1: ( rule__AccVarCS__Group_1__0__Impl rule__AccVarCS__Group_1__1 )
            // InternalMiniOCLCS.g:3725:2: rule__AccVarCS__Group_1__0__Impl rule__AccVarCS__Group_1__1
            {
            pushFollow(FOLLOW_6);
            rule__AccVarCS__Group_1__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:3732:1: rule__AccVarCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__AccVarCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3736:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:3737:1: ( ':' )
            {
            // InternalMiniOCLCS.g:3737:1: ( ':' )
            // InternalMiniOCLCS.g:3738:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getColonKeyword_1_0()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getColonKeyword_1_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AccVarCS__Group_1__1"
    // InternalMiniOCLCS.g:3747:1: rule__AccVarCS__Group_1__1 : rule__AccVarCS__Group_1__1__Impl ;
    public final void rule__AccVarCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3751:1: ( rule__AccVarCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:3752:2: rule__AccVarCS__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__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__AccVarCS__Group_1__1"


    // $ANTLR start "rule__AccVarCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:3758:1: rule__AccVarCS__Group_1__1__Impl : ( ( rule__AccVarCS__AccTypeAssignment_1_1 ) ) ;
    public final void rule__AccVarCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3762:1: ( ( ( rule__AccVarCS__AccTypeAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:3763:1: ( ( rule__AccVarCS__AccTypeAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:3763:1: ( ( rule__AccVarCS__AccTypeAssignment_1_1 ) )
            // InternalMiniOCLCS.g:3764:2: ( rule__AccVarCS__AccTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccTypeAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:3765:2: ( rule__AccVarCS__AccTypeAssignment_1_1 )
            // InternalMiniOCLCS.g:3765:3: rule__AccVarCS__AccTypeAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__AccVarCS__AccTypeAssignment_1_1();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccTypeAssignment_1_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__NameExpCS__Group__0"
    // InternalMiniOCLCS.g:3774: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 {
            // InternalMiniOCLCS.g:3778:1: ( rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 )
            // InternalMiniOCLCS.g:3779:2: rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1
            {
            pushFollow(FOLLOW_21);
            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"
    // InternalMiniOCLCS.g:3786:1: rule__NameExpCS__Group__0__Impl : ( ( rule__NameExpCS__ExpNameAssignment_0 ) ) ;
    public final void rule__NameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3790:1: ( ( ( rule__NameExpCS__ExpNameAssignment_0 ) ) )
            // InternalMiniOCLCS.g:3791:1: ( ( rule__NameExpCS__ExpNameAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:3791:1: ( ( rule__NameExpCS__ExpNameAssignment_0 ) )
            // InternalMiniOCLCS.g:3792:2: ( rule__NameExpCS__ExpNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getExpNameAssignment_0()); 
            }
            // InternalMiniOCLCS.g:3793:2: ( rule__NameExpCS__ExpNameAssignment_0 )
            // InternalMiniOCLCS.g:3793:3: rule__NameExpCS__ExpNameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__NameExpCS__ExpNameAssignment_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getExpNameAssignment_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"
    // InternalMiniOCLCS.g:3801:1: rule__NameExpCS__Group__1 : rule__NameExpCS__Group__1__Impl ;
    public final void rule__NameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3805:1: ( rule__NameExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:3806:2: rule__NameExpCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__NameExpCS__Group__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__1"


    // $ANTLR start "rule__NameExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3812:1: rule__NameExpCS__Group__1__Impl : ( ( rule__NameExpCS__RoundedBracketsAssignment_1 )? ) ;
    public final void rule__NameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3816:1: ( ( ( rule__NameExpCS__RoundedBracketsAssignment_1 )? ) )
            // InternalMiniOCLCS.g:3817:1: ( ( rule__NameExpCS__RoundedBracketsAssignment_1 )? )
            {
            // InternalMiniOCLCS.g:3817:1: ( ( rule__NameExpCS__RoundedBracketsAssignment_1 )? )
            // InternalMiniOCLCS.g:3818:2: ( rule__NameExpCS__RoundedBracketsAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getRoundedBracketsAssignment_1()); 
            }
            // InternalMiniOCLCS.g:3819:2: ( rule__NameExpCS__RoundedBracketsAssignment_1 )?
            int alt27=2;
            int LA27_0 = input.LA(1);

            if ( (LA27_0==30) ) {
                alt27=1;
            }
            switch (alt27) {
                case 1 :
                    // InternalMiniOCLCS.g:3819:3: rule__NameExpCS__RoundedBracketsAssignment_1
                    {
                    pushFollow(FOLLOW_2);
                    rule__NameExpCS__RoundedBracketsAssignment_1();

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

                    }
                    break;

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__0"
    // InternalMiniOCLCS.g:3828:1: rule__RoundedBracketClauseCS__Group__0 : rule__RoundedBracketClauseCS__Group__0__Impl rule__RoundedBracketClauseCS__Group__1 ;
    public final void rule__RoundedBracketClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3832:1: ( rule__RoundedBracketClauseCS__Group__0__Impl rule__RoundedBracketClauseCS__Group__1 )
            // InternalMiniOCLCS.g:3833:2: rule__RoundedBracketClauseCS__Group__0__Impl rule__RoundedBracketClauseCS__Group__1
            {
            pushFollow(FOLLOW_21);
            rule__RoundedBracketClauseCS__Group__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__0__Impl"
    // InternalMiniOCLCS.g:3840:1: rule__RoundedBracketClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__RoundedBracketClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3844:1: ( ( () ) )
            // InternalMiniOCLCS.g:3845:1: ( () )
            {
            // InternalMiniOCLCS.g:3845:1: ( () )
            // InternalMiniOCLCS.g:3846:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getRoundedBracketClauseCSAction_0()); 
            }
            // InternalMiniOCLCS.g:3847:2: ()
            // InternalMiniOCLCS.g:3847:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getRoundedBracketClauseCSAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__1"
    // InternalMiniOCLCS.g:3855:1: rule__RoundedBracketClauseCS__Group__1 : rule__RoundedBracketClauseCS__Group__1__Impl rule__RoundedBracketClauseCS__Group__2 ;
    public final void rule__RoundedBracketClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3859:1: ( rule__RoundedBracketClauseCS__Group__1__Impl rule__RoundedBracketClauseCS__Group__2 )
            // InternalMiniOCLCS.g:3860:2: rule__RoundedBracketClauseCS__Group__1__Impl rule__RoundedBracketClauseCS__Group__2
            {
            pushFollow(FOLLOW_38);
            rule__RoundedBracketClauseCS__Group__1__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__1__Impl"
    // InternalMiniOCLCS.g:3867:1: rule__RoundedBracketClauseCS__Group__1__Impl : ( '(' ) ;
    public final void rule__RoundedBracketClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3871:1: ( ( '(' ) )
            // InternalMiniOCLCS.g:3872:1: ( '(' )
            {
            // InternalMiniOCLCS.g:3872:1: ( '(' )
            // InternalMiniOCLCS.g:3873:2: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getLeftParenthesisKeyword_1()); 
            }
            match(input,30,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getLeftParenthesisKeyword_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__2"
    // InternalMiniOCLCS.g:3882:1: rule__RoundedBracketClauseCS__Group__2 : rule__RoundedBracketClauseCS__Group__2__Impl rule__RoundedBracketClauseCS__Group__3 ;
    public final void rule__RoundedBracketClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3886:1: ( rule__RoundedBracketClauseCS__Group__2__Impl rule__RoundedBracketClauseCS__Group__3 )
            // InternalMiniOCLCS.g:3887:2: rule__RoundedBracketClauseCS__Group__2__Impl rule__RoundedBracketClauseCS__Group__3
            {
            pushFollow(FOLLOW_38);
            rule__RoundedBracketClauseCS__Group__2__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__2__Impl"
    // InternalMiniOCLCS.g:3894:1: rule__RoundedBracketClauseCS__Group__2__Impl : ( ( rule__RoundedBracketClauseCS__Group_2__0 )? ) ;
    public final void rule__RoundedBracketClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3898:1: ( ( ( rule__RoundedBracketClauseCS__Group_2__0 )? ) )
            // InternalMiniOCLCS.g:3899:1: ( ( rule__RoundedBracketClauseCS__Group_2__0 )? )
            {
            // InternalMiniOCLCS.g:3899:1: ( ( rule__RoundedBracketClauseCS__Group_2__0 )? )
            // InternalMiniOCLCS.g:3900:2: ( rule__RoundedBracketClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getGroup_2()); 
            }
            // InternalMiniOCLCS.g:3901:2: ( rule__RoundedBracketClauseCS__Group_2__0 )?
            int alt28=2;
            int LA28_0 = input.LA(1);

            if ( (LA28_0==RULE_ID||LA28_0==RULE_INT||LA28_0==11||LA28_0==16||LA28_0==35||(LA28_0>=39 && LA28_0<=40)||LA28_0==45) ) {
                alt28=1;
            }
            switch (alt28) {
                case 1 :
                    // InternalMiniOCLCS.g:3901:3: rule__RoundedBracketClauseCS__Group_2__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__RoundedBracketClauseCS__Group_2__0();

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

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getGroup_2()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__3"
    // InternalMiniOCLCS.g:3909:1: rule__RoundedBracketClauseCS__Group__3 : rule__RoundedBracketClauseCS__Group__3__Impl ;
    public final void rule__RoundedBracketClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3913:1: ( rule__RoundedBracketClauseCS__Group__3__Impl )
            // InternalMiniOCLCS.g:3914:2: rule__RoundedBracketClauseCS__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__Group__3__Impl();

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group__3__Impl"
    // InternalMiniOCLCS.g:3920:1: rule__RoundedBracketClauseCS__Group__3__Impl : ( ')' ) ;
    public final void rule__RoundedBracketClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3924:1: ( ( ')' ) )
            // InternalMiniOCLCS.g:3925:1: ( ')' )
            {
            // InternalMiniOCLCS.g:3925:1: ( ')' )
            // InternalMiniOCLCS.g:3926:2: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getRightParenthesisKeyword_3()); 
            }
            match(input,31,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getRightParenthesisKeyword_3()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2__0"
    // InternalMiniOCLCS.g:3936:1: rule__RoundedBracketClauseCS__Group_2__0 : rule__RoundedBracketClauseCS__Group_2__0__Impl rule__RoundedBracketClauseCS__Group_2__1 ;
    public final void rule__RoundedBracketClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3940:1: ( rule__RoundedBracketClauseCS__Group_2__0__Impl rule__RoundedBracketClauseCS__Group_2__1 )
            // InternalMiniOCLCS.g:3941:2: rule__RoundedBracketClauseCS__Group_2__0__Impl rule__RoundedBracketClauseCS__Group_2__1
            {
            pushFollow(FOLLOW_25);
            rule__RoundedBracketClauseCS__Group_2__0__Impl();

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

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

            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2__0__Impl"
    // InternalMiniOCLCS.g:3948:1: rule__RoundedBracketClauseCS__Group_2__0__Impl : ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 ) ) ;
    public final void rule__RoundedBracketClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3952:1: ( ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 ) ) )
            // InternalMiniOCLCS.g:3953:1: ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 ) )
            {
            // InternalMiniOCLCS.g:3953:1: ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 ) )
            // InternalMiniOCLCS.g:3954:2: ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getArgsAssignment_2_0()); 
            }
            // InternalMiniOCLCS.g:3955:2: ( rule__RoundedBracketClauseCS__ArgsAssignment_2_0 )
            // InternalMiniOCLCS.g:3955:3: rule__RoundedBracketClauseCS__ArgsAssignment_2_0
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__ArgsAssignment_2_0();

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

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getArgsAssignment_2_0()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2__1"
    // InternalMiniOCLCS.g:3963:1: rule__RoundedBracketClauseCS__Group_2__1 : rule__RoundedBracketClauseCS__Group_2__1__Impl ;
    public final void rule__RoundedBracketClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3967:1: ( rule__RoundedBracketClauseCS__Group_2__1__Impl )
            // InternalMiniOCLCS.g:3968:2: rule__RoundedBracketClauseCS__Group_2__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__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__RoundedBracketClauseCS__Group_2__1"


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2__1__Impl"
    // InternalMiniOCLCS.g:3974:1: rule__RoundedBracketClauseCS__Group_2__1__Impl : ( ( rule__RoundedBracketClauseCS__Group_2_1__0 )* ) ;
    public final void rule__RoundedBracketClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3978:1: ( ( ( rule__RoundedBracketClauseCS__Group_2_1__0 )* ) )
            // InternalMiniOCLCS.g:3979:1: ( ( rule__RoundedBracketClauseCS__Group_2_1__0 )* )
            {
            // InternalMiniOCLCS.g:3979:1: ( ( rule__RoundedBracketClauseCS__Group_2_1__0 )* )
            // InternalMiniOCLCS.g:3980:2: ( rule__RoundedBracketClauseCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getGroup_2_1()); 
            }
            // InternalMiniOCLCS.g:3981:2: ( rule__RoundedBracketClauseCS__Group_2_1__0 )*
            loop29:
            do {
                int alt29=2;
                int LA29_0 = input.LA(1);

                if ( (LA29_0==32) ) {
                    alt29=1;
                }


                switch (alt29) {
            	case 1 :
            	    // InternalMiniOCLCS.g:3981:3: rule__RoundedBracketClauseCS__Group_2_1__0
            	    {
            	    pushFollow(FOLLOW_26);
            	    rule__RoundedBracketClauseCS__Group_2_1__0();

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

            	    }
            	    break;

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

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getGroup_2_1()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2_1__0"
    // InternalMiniOCLCS.g:3990:1: rule__RoundedBracketClauseCS__Group_2_1__0 : rule__RoundedBracketClauseCS__Group_2_1__0__Impl rule__RoundedBracketClauseCS__Group_2_1__1 ;
    public final void rule__RoundedBracketClauseCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:3994:1: ( rule__RoundedBracketClauseCS__Group_2_1__0__Impl rule__RoundedBracketClauseCS__Group_2_1__1 )
            // InternalMiniOCLCS.g:3995:2: rule__RoundedBracketClauseCS__Group_2_1__0__Impl rule__RoundedBracketClauseCS__Group_2_1__1
            {
            pushFollow(FOLLOW_24);
            rule__RoundedBracketClauseCS__Group_2_1__0__Impl();

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


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2_1__0__Impl"
    // InternalMiniOCLCS.g:4002:1: rule__RoundedBracketClauseCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__RoundedBracketClauseCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4006:1: ( ( ',' ) )
            // InternalMiniOCLCS.g:4007:1: ( ',' )
            {
            // InternalMiniOCLCS.g:4007:1: ( ',' )
            // InternalMiniOCLCS.g:4008:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getCommaKeyword_2_1_0()); 
            }
            match(input,32,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getCommaKeyword_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundedBracketClauseCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2_1__1"
    // InternalMiniOCLCS.g:4017:1: rule__RoundedBracketClauseCS__Group_2_1__1 : rule__RoundedBracketClauseCS__Group_2_1__1__Impl ;
    public final void rule__RoundedBracketClauseCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4021:1: ( rule__RoundedBracketClauseCS__Group_2_1__1__Impl )
            // InternalMiniOCLCS.g:4022:2: rule__RoundedBracketClauseCS__Group_2_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__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__RoundedBracketClauseCS__Group_2_1__1"


    // $ANTLR start "rule__RoundedBracketClauseCS__Group_2_1__1__Impl"
    // InternalMiniOCLCS.g:4028:1: rule__RoundedBracketClauseCS__Group_2_1__1__Impl : ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 ) ) ;
    public final void rule__RoundedBracketClauseCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4032:1: ( ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 ) ) )
            // InternalMiniOCLCS.g:4033:1: ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 ) )
            {
            // InternalMiniOCLCS.g:4033:1: ( ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 ) )
            // InternalMiniOCLCS.g:4034:2: ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getArgsAssignment_2_1_1()); 
            }
            // InternalMiniOCLCS.g:4035:2: ( rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 )
            // InternalMiniOCLCS.g:4035:3: rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1
            {
            pushFollow(FOLLOW_2);
            rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getArgsAssignment_2_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundedBracketClauseCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__BooleanLiteralExpCS__Group__0"
    // InternalMiniOCLCS.g:4044:1: rule__BooleanLiteralExpCS__Group__0 : rule__BooleanLiteralExpCS__Group__0__Impl rule__BooleanLiteralExpCS__Group__1 ;
    public final void rule__BooleanLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4048:1: ( rule__BooleanLiteralExpCS__Group__0__Impl rule__BooleanLiteralExpCS__Group__1 )
            // InternalMiniOCLCS.g:4049:2: rule__BooleanLiteralExpCS__Group__0__Impl rule__BooleanLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_39);
            rule__BooleanLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__BooleanLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Group__0"


    // $ANTLR start "rule__BooleanLiteralExpCS__Group__0__Impl"
    // InternalMiniOCLCS.g:4056:1: rule__BooleanLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__BooleanLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4060:1: ( ( () ) )
            // InternalMiniOCLCS.g:4061:1: ( () )
            {
            // InternalMiniOCLCS.g:4061:1: ( () )
            // InternalMiniOCLCS.g:4062:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getBooleanExpCSAction_0()); 
            }
            // InternalMiniOCLCS.g:4063:2: ()
            // InternalMiniOCLCS.g:4063:3: 
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getBooleanExpCSAction_0()); 
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__BooleanLiteralExpCS__Group__1"
    // InternalMiniOCLCS.g:4071:1: rule__BooleanLiteralExpCS__Group__1 : rule__BooleanLiteralExpCS__Group__1__Impl ;
    public final void rule__BooleanLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4075:1: ( rule__BooleanLiteralExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:4076:2: rule__BooleanLiteralExpCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__BooleanLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Group__1"


    // $ANTLR start "rule__BooleanLiteralExpCS__Group__1__Impl"
    // InternalMiniOCLCS.g:4082:1: rule__BooleanLiteralExpCS__Group__1__Impl : ( ( rule__BooleanLiteralExpCS__Alternatives_1 ) ) ;
    public final void rule__BooleanLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4086:1: ( ( ( rule__BooleanLiteralExpCS__Alternatives_1 ) ) )
            // InternalMiniOCLCS.g:4087:1: ( ( rule__BooleanLiteralExpCS__Alternatives_1 ) )
            {
            // InternalMiniOCLCS.g:4087:1: ( ( rule__BooleanLiteralExpCS__Alternatives_1 ) )
            // InternalMiniOCLCS.g:4088:2: ( rule__BooleanLiteralExpCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives_1()); 
            }
            // InternalMiniOCLCS.g:4089:2: ( rule__BooleanLiteralExpCS__Alternatives_1 )
            // InternalMiniOCLCS.g:4089:3: rule__BooleanLiteralExpCS__Alternatives_1
            {
            pushFollow(FOLLOW_2);
            rule__BooleanLiteralExpCS__Alternatives_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__NullLiteralExpCS__Group__0"
    // InternalMiniOCLCS.g:4098: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 {
            // InternalMiniOCLCS.g:4102:1: ( rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 )
            // InternalMiniOCLCS.g:4103:2: rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_40);
            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"
    // InternalMiniOCLCS.g:4110:1: rule__NullLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__NullLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4114:1: ( ( () ) )
            // InternalMiniOCLCS.g:4115:1: ( () )
            {
            // InternalMiniOCLCS.g:4115:1: ( () )
            // InternalMiniOCLCS.g:4116:2: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0()); 
            }
            // InternalMiniOCLCS.g:4117:2: ()
            // InternalMiniOCLCS.g:4117: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"
    // InternalMiniOCLCS.g:4125:1: rule__NullLiteralExpCS__Group__1 : rule__NullLiteralExpCS__Group__1__Impl ;
    public final void rule__NullLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4129:1: ( rule__NullLiteralExpCS__Group__1__Impl )
            // InternalMiniOCLCS.g:4130: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"
    // InternalMiniOCLCS.g:4136:1: rule__NullLiteralExpCS__Group__1__Impl : ( 'null' ) ;
    public final void rule__NullLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4140:1: ( ( 'null' ) )
            // InternalMiniOCLCS.g:4141:1: ( 'null' )
            {
            // InternalMiniOCLCS.g:4141:1: ( 'null' )
            // InternalMiniOCLCS.g:4142:2: 'null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1()); 
            }
            match(input,39,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__CollectionLiteralExpCS__Group__0"
    // InternalMiniOCLCS.g:4152: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 {
            // InternalMiniOCLCS.g:4156:1: ( rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 )
            // InternalMiniOCLCS.g:4157:2: rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1
            {
            pushFollow(FOLLOW_10);
            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"
    // InternalMiniOCLCS.g:4164:1: rule__CollectionLiteralExpCS__Group__0__Impl : ( ( rule__CollectionLiteralExpCS__KindAssignment_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4168:1: ( ( ( rule__CollectionLiteralExpCS__KindAssignment_0 ) ) )
            // InternalMiniOCLCS.g:4169:1: ( ( rule__CollectionLiteralExpCS__KindAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:4169:1: ( ( rule__CollectionLiteralExpCS__KindAssignment_0 ) )
            // InternalMiniOCLCS.g:4170:2: ( rule__CollectionLiteralExpCS__KindAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getKindAssignment_0()); 
            }
            // InternalMiniOCLCS.g:4171:2: ( rule__CollectionLiteralExpCS__KindAssignment_0 )
            // InternalMiniOCLCS.g:4171:3: rule__CollectionLiteralExpCS__KindAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralExpCS__KindAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getKindAssignment_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"
    // InternalMiniOCLCS.g:4179: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 {
            // InternalMiniOCLCS.g:4183:1: ( rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 )
            // InternalMiniOCLCS.g:4184:2: rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2
            {
            pushFollow(FOLLOW_41);
            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"
    // InternalMiniOCLCS.g:4191:1: rule__CollectionLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4195:1: ( ( '{' ) )
            // InternalMiniOCLCS.g:4196:1: ( '{' )
            {
            // InternalMiniOCLCS.g:4196:1: ( '{' )
            // InternalMiniOCLCS.g:4197:2: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1()); 
            }
            match(input,21,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"
    // InternalMiniOCLCS.g:4206: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 {
            // InternalMiniOCLCS.g:4210:1: ( rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 )
            // InternalMiniOCLCS.g:4211:2: rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3
            {
            pushFollow(FOLLOW_41);
            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"
    // InternalMiniOCLCS.g:4218:1: rule__CollectionLiteralExpCS__Group__2__Impl : ( ( rule__CollectionLiteralExpCS__PartsAssignment_2 )* ) ;
    public final void rule__CollectionLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4222:1: ( ( ( rule__CollectionLiteralExpCS__PartsAssignment_2 )* ) )
            // InternalMiniOCLCS.g:4223:1: ( ( rule__CollectionLiteralExpCS__PartsAssignment_2 )* )
            {
            // InternalMiniOCLCS.g:4223:1: ( ( rule__CollectionLiteralExpCS__PartsAssignment_2 )* )
            // InternalMiniOCLCS.g:4224:2: ( rule__CollectionLiteralExpCS__PartsAssignment_2 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getPartsAssignment_2()); 
            }
            // InternalMiniOCLCS.g:4225:2: ( rule__CollectionLiteralExpCS__PartsAssignment_2 )*
            loop30:
            do {
                int alt30=2;
                int LA30_0 = input.LA(1);

                if ( (LA30_0==RULE_ID||LA30_0==RULE_INT||LA30_0==11||LA30_0==16||LA30_0==35||(LA30_0>=39 && LA30_0<=40)||LA30_0==45) ) {
                    alt30=1;
                }


                switch (alt30) {
            	case 1 :
            	    // InternalMiniOCLCS.g:4225:3: rule__CollectionLiteralExpCS__PartsAssignment_2
            	    {
            	    pushFollow(FOLLOW_42);
            	    rule__CollectionLiteralExpCS__PartsAssignment_2();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop30;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getPartsAssignment_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"
    // InternalMiniOCLCS.g:4233:1: rule__CollectionLiteralExpCS__Group__3 : rule__CollectionLiteralExpCS__Group__3__Impl ;
    public final void rule__CollectionLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4237:1: ( rule__CollectionLiteralExpCS__Group__3__Impl )
            // InternalMiniOCLCS.g:4238: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"
    // InternalMiniOCLCS.g:4244:1: rule__CollectionLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4248:1: ( ( '}' ) )
            // InternalMiniOCLCS.g:4249:1: ( '}' )
            {
            // InternalMiniOCLCS.g:4249:1: ( '}' )
            // InternalMiniOCLCS.g:4250:2: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3()); 
            }
            match(input,22,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__CollectionLiteralPartCS__Group__0"
    // InternalMiniOCLCS.g:4260:1: rule__CollectionLiteralPartCS__Group__0 : rule__CollectionLiteralPartCS__Group__0__Impl rule__CollectionLiteralPartCS__Group__1 ;
    public final void rule__CollectionLiteralPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4264:1: ( rule__CollectionLiteralPartCS__Group__0__Impl rule__CollectionLiteralPartCS__Group__1 )
            // InternalMiniOCLCS.g:4265:2: rule__CollectionLiteralPartCS__Group__0__Impl rule__CollectionLiteralPartCS__Group__1
            {
            pushFollow(FOLLOW_19);
            rule__CollectionLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__Group__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"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group__0__Impl"
    // InternalMiniOCLCS.g:4272:1: rule__CollectionLiteralPartCS__Group__0__Impl : ( ( rule__CollectionLiteralPartCS__FirstAssignment_0 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4276:1: ( ( ( rule__CollectionLiteralPartCS__FirstAssignment_0 ) ) )
            // InternalMiniOCLCS.g:4277:1: ( ( rule__CollectionLiteralPartCS__FirstAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:4277:1: ( ( rule__CollectionLiteralPartCS__FirstAssignment_0 ) )
            // InternalMiniOCLCS.g:4278:2: ( rule__CollectionLiteralPartCS__FirstAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFirstAssignment_0()); 
            }
            // InternalMiniOCLCS.g:4279:2: ( rule__CollectionLiteralPartCS__FirstAssignment_0 )
            // InternalMiniOCLCS.g:4279:3: rule__CollectionLiteralPartCS__FirstAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__FirstAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getFirstAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group__1"
    // InternalMiniOCLCS.g:4287:1: rule__CollectionLiteralPartCS__Group__1 : rule__CollectionLiteralPartCS__Group__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4291:1: ( rule__CollectionLiteralPartCS__Group__1__Impl )
            // InternalMiniOCLCS.g:4292:2: rule__CollectionLiteralPartCS__Group__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__Group__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__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group__1__Impl"
    // InternalMiniOCLCS.g:4298:1: rule__CollectionLiteralPartCS__Group__1__Impl : ( ( rule__CollectionLiteralPartCS__Group_1__0 )? ) ;
    public final void rule__CollectionLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4302:1: ( ( ( rule__CollectionLiteralPartCS__Group_1__0 )? ) )
            // InternalMiniOCLCS.g:4303:1: ( ( rule__CollectionLiteralPartCS__Group_1__0 )? )
            {
            // InternalMiniOCLCS.g:4303:1: ( ( rule__CollectionLiteralPartCS__Group_1__0 )? )
            // InternalMiniOCLCS.g:4304:2: ( rule__CollectionLiteralPartCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:4305:2: ( rule__CollectionLiteralPartCS__Group_1__0 )?
            int alt31=2;
            int LA31_0 = input.LA(1);

            if ( (LA31_0==28) ) {
                alt31=1;
            }
            switch (alt31) {
                case 1 :
                    // InternalMiniOCLCS.g:4305:3: rule__CollectionLiteralPartCS__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__CollectionLiteralPartCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_1__0"
    // InternalMiniOCLCS.g:4314:1: rule__CollectionLiteralPartCS__Group_1__0 : rule__CollectionLiteralPartCS__Group_1__0__Impl rule__CollectionLiteralPartCS__Group_1__1 ;
    public final void rule__CollectionLiteralPartCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4318:1: ( rule__CollectionLiteralPartCS__Group_1__0__Impl rule__CollectionLiteralPartCS__Group_1__1 )
            // InternalMiniOCLCS.g:4319:2: rule__CollectionLiteralPartCS__Group_1__0__Impl rule__CollectionLiteralPartCS__Group_1__1
            {
            pushFollow(FOLLOW_24);
            rule__CollectionLiteralPartCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_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_1__0"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:4326:1: rule__CollectionLiteralPartCS__Group_1__0__Impl : ( '..' ) ;
    public final void rule__CollectionLiteralPartCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4330:1: ( ( '..' ) )
            // InternalMiniOCLCS.g:4331:1: ( '..' )
            {
            // InternalMiniOCLCS.g:4331:1: ( '..' )
            // InternalMiniOCLCS.g:4332:2: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_1_0()); 
            }
            match(input,28,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_1__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_1__1"
    // InternalMiniOCLCS.g:4341:1: rule__CollectionLiteralPartCS__Group_1__1 : rule__CollectionLiteralPartCS__Group_1__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4345:1: ( rule__CollectionLiteralPartCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:4346:2: rule__CollectionLiteralPartCS__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__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__CollectionLiteralPartCS__Group_1__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:4352:1: rule__CollectionLiteralPartCS__Group_1__1__Impl : ( ( rule__CollectionLiteralPartCS__LastAssignment_1_1 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4356:1: ( ( ( rule__CollectionLiteralPartCS__LastAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:4357:1: ( ( rule__CollectionLiteralPartCS__LastAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:4357:1: ( ( rule__CollectionLiteralPartCS__LastAssignment_1_1 ) )
            // InternalMiniOCLCS.g:4358:2: ( rule__CollectionLiteralPartCS__LastAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getLastAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:4359:2: ( rule__CollectionLiteralPartCS__LastAssignment_1_1 )
            // InternalMiniOCLCS.g:4359:3: rule__CollectionLiteralPartCS__LastAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__CollectionLiteralPartCS__LastAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getLastAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_1__1__Impl"


    // $ANTLR start "rule__LetExpCS__Group__0"
    // InternalMiniOCLCS.g:4368: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 {
            // InternalMiniOCLCS.g:4372:1: ( rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 )
            // InternalMiniOCLCS.g:4373:2: rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1
            {
            pushFollow(FOLLOW_6);
            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"
    // InternalMiniOCLCS.g:4380:1: rule__LetExpCS__Group__0__Impl : ( 'let' ) ;
    public final void rule__LetExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4384:1: ( ( 'let' ) )
            // InternalMiniOCLCS.g:4385:1: ( 'let' )
            {
            // InternalMiniOCLCS.g:4385:1: ( 'let' )
            // InternalMiniOCLCS.g:4386:2: 'let'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetKeyword_0()); 
            }
            match(input,40,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"
    // InternalMiniOCLCS.g:4395: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 {
            // InternalMiniOCLCS.g:4399:1: ( rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 )
            // InternalMiniOCLCS.g:4400:2: rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2
            {
            pushFollow(FOLLOW_43);
            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"
    // InternalMiniOCLCS.g:4407:1: rule__LetExpCS__Group__1__Impl : ( ( rule__LetExpCS__LetVarsAssignment_1 ) ) ;
    public final void rule__LetExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4411:1: ( ( ( rule__LetExpCS__LetVarsAssignment_1 ) ) )
            // InternalMiniOCLCS.g:4412:1: ( ( rule__LetExpCS__LetVarsAssignment_1 ) )
            {
            // InternalMiniOCLCS.g:4412:1: ( ( rule__LetExpCS__LetVarsAssignment_1 ) )
            // InternalMiniOCLCS.g:4413:2: ( rule__LetExpCS__LetVarsAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetVarsAssignment_1()); 
            }
            // InternalMiniOCLCS.g:4414:2: ( rule__LetExpCS__LetVarsAssignment_1 )
            // InternalMiniOCLCS.g:4414:3: rule__LetExpCS__LetVarsAssignment_1
            {
            pushFollow(FOLLOW_2);
            rule__LetExpCS__LetVarsAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetVarsAssignment_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"
    // InternalMiniOCLCS.g:4422: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 {
            // InternalMiniOCLCS.g:4426:1: ( rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 )
            // InternalMiniOCLCS.g:4427:2: rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3
            {
            pushFollow(FOLLOW_43);
            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"
    // InternalMiniOCLCS.g:4434: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 {
            // InternalMiniOCLCS.g:4438:1: ( ( ( rule__LetExpCS__Group_2__0 )* ) )
            // InternalMiniOCLCS.g:4439:1: ( ( rule__LetExpCS__Group_2__0 )* )
            {
            // InternalMiniOCLCS.g:4439:1: ( ( rule__LetExpCS__Group_2__0 )* )
            // InternalMiniOCLCS.g:4440:2: ( rule__LetExpCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup_2()); 
            }
            // InternalMiniOCLCS.g:4441:2: ( rule__LetExpCS__Group_2__0 )*
            loop32:
            do {
                int alt32=2;
                int LA32_0 = input.LA(1);

                if ( (LA32_0==32) ) {
                    alt32=1;
                }


                switch (alt32) {
            	case 1 :
            	    // InternalMiniOCLCS.g:4441:3: rule__LetExpCS__Group_2__0
            	    {
            	    pushFollow(FOLLOW_26);
            	    rule__LetExpCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop32;
                }
            } 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"
    // InternalMiniOCLCS.g:4449: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 {
            // InternalMiniOCLCS.g:4453:1: ( rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 )
            // InternalMiniOCLCS.g:4454:2: rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4
            {
            pushFollow(FOLLOW_24);
            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"
    // InternalMiniOCLCS.g:4461:1: rule__LetExpCS__Group__3__Impl : ( 'in' ) ;
    public final void rule__LetExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4465:1: ( ( 'in' ) )
            // InternalMiniOCLCS.g:4466:1: ( 'in' )
            {
            // InternalMiniOCLCS.g:4466:1: ( 'in' )
            // InternalMiniOCLCS.g:4467:2: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInKeyword_3()); 
            }
            match(input,41,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"
    // InternalMiniOCLCS.g:4476:1: rule__LetExpCS__Group__4 : rule__LetExpCS__Group__4__Impl ;
    public final void rule__LetExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4480:1: ( rule__LetExpCS__Group__4__Impl )
            // InternalMiniOCLCS.g:4481: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"
    // InternalMiniOCLCS.g:4487:1: rule__LetExpCS__Group__4__Impl : ( ( rule__LetExpCS__InExpAssignment_4 ) ) ;
    public final void rule__LetExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4491:1: ( ( ( rule__LetExpCS__InExpAssignment_4 ) ) )
            // InternalMiniOCLCS.g:4492:1: ( ( rule__LetExpCS__InExpAssignment_4 ) )
            {
            // InternalMiniOCLCS.g:4492:1: ( ( rule__LetExpCS__InExpAssignment_4 ) )
            // InternalMiniOCLCS.g:4493:2: ( rule__LetExpCS__InExpAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInExpAssignment_4()); 
            }
            // InternalMiniOCLCS.g:4494:2: ( rule__LetExpCS__InExpAssignment_4 )
            // InternalMiniOCLCS.g:4494:3: rule__LetExpCS__InExpAssignment_4
            {
            pushFollow(FOLLOW_2);
            rule__LetExpCS__InExpAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getInExpAssignment_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"
    // InternalMiniOCLCS.g:4503: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 {
            // InternalMiniOCLCS.g:4507:1: ( rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 )
            // InternalMiniOCLCS.g:4508:2: rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1
            {
            pushFollow(FOLLOW_6);
            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"
    // InternalMiniOCLCS.g:4515:1: rule__LetExpCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__LetExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4519:1: ( ( ',' ) )
            // InternalMiniOCLCS.g:4520:1: ( ',' )
            {
            // InternalMiniOCLCS.g:4520:1: ( ',' )
            // InternalMiniOCLCS.g:4521:2: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0()); 
            }
            match(input,32,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"
    // InternalMiniOCLCS.g:4530: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 {
            // InternalMiniOCLCS.g:4534:1: ( rule__LetExpCS__Group_2__1__Impl )
            // InternalMiniOCLCS.g:4535: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"
    // InternalMiniOCLCS.g:4541:1: rule__LetExpCS__Group_2__1__Impl : ( ( rule__LetExpCS__LetVarsAssignment_2_1 ) ) ;
    public final void rule__LetExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4545:1: ( ( ( rule__LetExpCS__LetVarsAssignment_2_1 ) ) )
            // InternalMiniOCLCS.g:4546:1: ( ( rule__LetExpCS__LetVarsAssignment_2_1 ) )
            {
            // InternalMiniOCLCS.g:4546:1: ( ( rule__LetExpCS__LetVarsAssignment_2_1 ) )
            // InternalMiniOCLCS.g:4547:2: ( rule__LetExpCS__LetVarsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetVarsAssignment_2_1()); 
            }
            // InternalMiniOCLCS.g:4548:2: ( rule__LetExpCS__LetVarsAssignment_2_1 )
            // InternalMiniOCLCS.g:4548:3: rule__LetExpCS__LetVarsAssignment_2_1
            {
            pushFollow(FOLLOW_2);
            rule__LetExpCS__LetVarsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetVarsAssignment_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__LetVarCS__Group__0"
    // InternalMiniOCLCS.g:4557:1: rule__LetVarCS__Group__0 : rule__LetVarCS__Group__0__Impl rule__LetVarCS__Group__1 ;
    public final void rule__LetVarCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4561:1: ( rule__LetVarCS__Group__0__Impl rule__LetVarCS__Group__1 )
            // InternalMiniOCLCS.g:4562:2: rule__LetVarCS__Group__0__Impl rule__LetVarCS__Group__1
            {
            pushFollow(FOLLOW_37);
            rule__LetVarCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__0"


    // $ANTLR start "rule__LetVarCS__Group__0__Impl"
    // InternalMiniOCLCS.g:4569:1: rule__LetVarCS__Group__0__Impl : ( ( rule__LetVarCS__NameAssignment_0 ) ) ;
    public final void rule__LetVarCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4573:1: ( ( ( rule__LetVarCS__NameAssignment_0 ) ) )
            // InternalMiniOCLCS.g:4574:1: ( ( rule__LetVarCS__NameAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:4574:1: ( ( rule__LetVarCS__NameAssignment_0 ) )
            // InternalMiniOCLCS.g:4575:2: ( rule__LetVarCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getNameAssignment_0()); 
            }
            // InternalMiniOCLCS.g:4576:2: ( rule__LetVarCS__NameAssignment_0 )
            // InternalMiniOCLCS.g:4576:3: rule__LetVarCS__NameAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getNameAssignment_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__0__Impl"


    // $ANTLR start "rule__LetVarCS__Group__1"
    // InternalMiniOCLCS.g:4584:1: rule__LetVarCS__Group__1 : rule__LetVarCS__Group__1__Impl rule__LetVarCS__Group__2 ;
    public final void rule__LetVarCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4588:1: ( rule__LetVarCS__Group__1__Impl rule__LetVarCS__Group__2 )
            // InternalMiniOCLCS.g:4589:2: rule__LetVarCS__Group__1__Impl rule__LetVarCS__Group__2
            {
            pushFollow(FOLLOW_37);
            rule__LetVarCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__1"


    // $ANTLR start "rule__LetVarCS__Group__1__Impl"
    // InternalMiniOCLCS.g:4596:1: rule__LetVarCS__Group__1__Impl : ( ( rule__LetVarCS__Group_1__0 )? ) ;
    public final void rule__LetVarCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4600:1: ( ( ( rule__LetVarCS__Group_1__0 )? ) )
            // InternalMiniOCLCS.g:4601:1: ( ( rule__LetVarCS__Group_1__0 )? )
            {
            // InternalMiniOCLCS.g:4601:1: ( ( rule__LetVarCS__Group_1__0 )? )
            // InternalMiniOCLCS.g:4602:2: ( rule__LetVarCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:4603:2: ( rule__LetVarCS__Group_1__0 )?
            int alt33=2;
            int LA33_0 = input.LA(1);

            if ( (LA33_0==19) ) {
                alt33=1;
            }
            switch (alt33) {
                case 1 :
                    // InternalMiniOCLCS.g:4603:3: rule__LetVarCS__Group_1__0
                    {
                    pushFollow(FOLLOW_2);
                    rule__LetVarCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getGroup_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__1__Impl"


    // $ANTLR start "rule__LetVarCS__Group__2"
    // InternalMiniOCLCS.g:4611:1: rule__LetVarCS__Group__2 : rule__LetVarCS__Group__2__Impl rule__LetVarCS__Group__3 ;
    public final void rule__LetVarCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4615:1: ( rule__LetVarCS__Group__2__Impl rule__LetVarCS__Group__3 )
            // InternalMiniOCLCS.g:4616:2: rule__LetVarCS__Group__2__Impl rule__LetVarCS__Group__3
            {
            pushFollow(FOLLOW_24);
            rule__LetVarCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__2"


    // $ANTLR start "rule__LetVarCS__Group__2__Impl"
    // InternalMiniOCLCS.g:4623:1: rule__LetVarCS__Group__2__Impl : ( '=' ) ;
    public final void rule__LetVarCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4627:1: ( ( '=' ) )
            // InternalMiniOCLCS.g:4628:1: ( '=' )
            {
            // InternalMiniOCLCS.g:4628:1: ( '=' )
            // InternalMiniOCLCS.g:4629:2: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getEqualsSignKeyword_2()); 
            }
            match(input,12,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getEqualsSignKeyword_2()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__2__Impl"


    // $ANTLR start "rule__LetVarCS__Group__3"
    // InternalMiniOCLCS.g:4638:1: rule__LetVarCS__Group__3 : rule__LetVarCS__Group__3__Impl ;
    public final void rule__LetVarCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4642:1: ( rule__LetVarCS__Group__3__Impl )
            // InternalMiniOCLCS.g:4643:2: rule__LetVarCS__Group__3__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__3"


    // $ANTLR start "rule__LetVarCS__Group__3__Impl"
    // InternalMiniOCLCS.g:4649:1: rule__LetVarCS__Group__3__Impl : ( ( rule__LetVarCS__InitExpAssignment_3 ) ) ;
    public final void rule__LetVarCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4653:1: ( ( ( rule__LetVarCS__InitExpAssignment_3 ) ) )
            // InternalMiniOCLCS.g:4654:1: ( ( rule__LetVarCS__InitExpAssignment_3 ) )
            {
            // InternalMiniOCLCS.g:4654:1: ( ( rule__LetVarCS__InitExpAssignment_3 ) )
            // InternalMiniOCLCS.g:4655:2: ( rule__LetVarCS__InitExpAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getInitExpAssignment_3()); 
            }
            // InternalMiniOCLCS.g:4656:2: ( rule__LetVarCS__InitExpAssignment_3 )
            // InternalMiniOCLCS.g:4656:3: rule__LetVarCS__InitExpAssignment_3
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__InitExpAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getInitExpAssignment_3()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group__3__Impl"


    // $ANTLR start "rule__LetVarCS__Group_1__0"
    // InternalMiniOCLCS.g:4665:1: rule__LetVarCS__Group_1__0 : rule__LetVarCS__Group_1__0__Impl rule__LetVarCS__Group_1__1 ;
    public final void rule__LetVarCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4669:1: ( rule__LetVarCS__Group_1__0__Impl rule__LetVarCS__Group_1__1 )
            // InternalMiniOCLCS.g:4670:2: rule__LetVarCS__Group_1__0__Impl rule__LetVarCS__Group_1__1
            {
            pushFollow(FOLLOW_6);
            rule__LetVarCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FOLLOW_2);
            rule__LetVarCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group_1__0"


    // $ANTLR start "rule__LetVarCS__Group_1__0__Impl"
    // InternalMiniOCLCS.g:4677:1: rule__LetVarCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__LetVarCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4681:1: ( ( ':' ) )
            // InternalMiniOCLCS.g:4682:1: ( ':' )
            {
            // InternalMiniOCLCS.g:4682:1: ( ':' )
            // InternalMiniOCLCS.g:4683:2: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getColonKeyword_1_0()); 
            }
            match(input,19,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getColonKeyword_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group_1__0__Impl"


    // $ANTLR start "rule__LetVarCS__Group_1__1"
    // InternalMiniOCLCS.g:4692:1: rule__LetVarCS__Group_1__1 : rule__LetVarCS__Group_1__1__Impl ;
    public final void rule__LetVarCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4696:1: ( rule__LetVarCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:4697:2: rule__LetVarCS__Group_1__1__Impl
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__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__LetVarCS__Group_1__1"


    // $ANTLR start "rule__LetVarCS__Group_1__1__Impl"
    // InternalMiniOCLCS.g:4703:1: rule__LetVarCS__Group_1__1__Impl : ( ( rule__LetVarCS__TypeRefAssignment_1_1 ) ) ;
    public final void rule__LetVarCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4707:1: ( ( ( rule__LetVarCS__TypeRefAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:4708:1: ( ( rule__LetVarCS__TypeRefAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:4708:1: ( ( rule__LetVarCS__TypeRefAssignment_1_1 ) )
            // InternalMiniOCLCS.g:4709:2: ( rule__LetVarCS__TypeRefAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getTypeRefAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:4710:2: ( rule__LetVarCS__TypeRefAssignment_1_1 )
            // InternalMiniOCLCS.g:4710:3: rule__LetVarCS__TypeRefAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__LetVarCS__TypeRefAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getTypeRefAssignment_1_1()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__Group_1__1__Impl"


    // $ANTLR start "rule__PathNameCS__Group__0"
    // InternalMiniOCLCS.g:4719: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 {
            // InternalMiniOCLCS.g:4723:1: ( rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 )
            // InternalMiniOCLCS.g:4724:2: rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1
            {
            pushFollow(FOLLOW_44);
            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"
    // InternalMiniOCLCS.g:4731:1: rule__PathNameCS__Group__0__Impl : ( ( rule__PathNameCS__PathElementsAssignment_0 ) ) ;
    public final void rule__PathNameCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4735:1: ( ( ( rule__PathNameCS__PathElementsAssignment_0 ) ) )
            // InternalMiniOCLCS.g:4736:1: ( ( rule__PathNameCS__PathElementsAssignment_0 ) )
            {
            // InternalMiniOCLCS.g:4736:1: ( ( rule__PathNameCS__PathElementsAssignment_0 ) )
            // InternalMiniOCLCS.g:4737:2: ( rule__PathNameCS__PathElementsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getPathElementsAssignment_0()); 
            }
            // InternalMiniOCLCS.g:4738:2: ( rule__PathNameCS__PathElementsAssignment_0 )
            // InternalMiniOCLCS.g:4738:3: rule__PathNameCS__PathElementsAssignment_0
            {
            pushFollow(FOLLOW_2);
            rule__PathNameCS__PathElementsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getPathElementsAssignment_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"
    // InternalMiniOCLCS.g:4746:1: rule__PathNameCS__Group__1 : rule__PathNameCS__Group__1__Impl ;
    public final void rule__PathNameCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4750:1: ( rule__PathNameCS__Group__1__Impl )
            // InternalMiniOCLCS.g:4751: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"
    // InternalMiniOCLCS.g:4757: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 {
            // InternalMiniOCLCS.g:4761:1: ( ( ( rule__PathNameCS__Group_1__0 )* ) )
            // InternalMiniOCLCS.g:4762:1: ( ( rule__PathNameCS__Group_1__0 )* )
            {
            // InternalMiniOCLCS.g:4762:1: ( ( rule__PathNameCS__Group_1__0 )* )
            // InternalMiniOCLCS.g:4763:2: ( rule__PathNameCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup_1()); 
            }
            // InternalMiniOCLCS.g:4764:2: ( rule__PathNameCS__Group_1__0 )*
            loop34:
            do {
                int alt34=2;
                int LA34_0 = input.LA(1);

                if ( (LA34_0==42) ) {
                    alt34=1;
                }


                switch (alt34) {
            	case 1 :
            	    // InternalMiniOCLCS.g:4764:3: rule__PathNameCS__Group_1__0
            	    {
            	    pushFollow(FOLLOW_45);
            	    rule__PathNameCS__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop34;
                }
            } 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"
    // InternalMiniOCLCS.g:4773: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 {
            // InternalMiniOCLCS.g:4777:1: ( rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 )
            // InternalMiniOCLCS.g:4778:2: rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1
            {
            pushFollow(FOLLOW_6);
            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"
    // InternalMiniOCLCS.g:4785:1: rule__PathNameCS__Group_1__0__Impl : ( '::' ) ;
    public final void rule__PathNameCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4789:1: ( ( '::' ) )
            // InternalMiniOCLCS.g:4790:1: ( '::' )
            {
            // InternalMiniOCLCS.g:4790:1: ( '::' )
            // InternalMiniOCLCS.g:4791:2: '::'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0()); 
            }
            match(input,42,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"
    // InternalMiniOCLCS.g:4800: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 {
            // InternalMiniOCLCS.g:4804:1: ( rule__PathNameCS__Group_1__1__Impl )
            // InternalMiniOCLCS.g:4805: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"
    // InternalMiniOCLCS.g:4811:1: rule__PathNameCS__Group_1__1__Impl : ( ( rule__PathNameCS__PathElementsAssignment_1_1 ) ) ;
    public final void rule__PathNameCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4815:1: ( ( ( rule__PathNameCS__PathElementsAssignment_1_1 ) ) )
            // InternalMiniOCLCS.g:4816:1: ( ( rule__PathNameCS__PathElementsAssignment_1_1 ) )
            {
            // InternalMiniOCLCS.g:4816:1: ( ( rule__PathNameCS__PathElementsAssignment_1_1 ) )
            // InternalMiniOCLCS.g:4817:2: ( rule__PathNameCS__PathElementsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getPathElementsAssignment_1_1()); 
            }
            // InternalMiniOCLCS.g:4818:2: ( rule__PathNameCS__PathElementsAssignment_1_1 )
            // InternalMiniOCLCS.g:4818:3: rule__PathNameCS__PathElementsAssignment_1_1
            {
            pushFollow(FOLLOW_2);
            rule__PathNameCS__PathElementsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getPathElementsAssignment_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__RootCS__ImportsAssignment_0"
    // InternalMiniOCLCS.g:4827:1: rule__RootCS__ImportsAssignment_0 : ( ruleImportCS ) ;
    public final void rule__RootCS__ImportsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4831:1: ( ( ruleImportCS ) )
            // InternalMiniOCLCS.g:4832:2: ( ruleImportCS )
            {
            // InternalMiniOCLCS.g:4832:2: ( ruleImportCS )
            // InternalMiniOCLCS.g:4833:3: ruleImportCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRootCSAccess().getImportsImportCSParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleImportCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRootCSAccess().getImportsImportCSParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RootCS__ImportsAssignment_0"


    // $ANTLR start "rule__RootCS__PackagesAssignment_1_0"
    // InternalMiniOCLCS.g:4842:1: rule__RootCS__PackagesAssignment_1_0 : ( rulePackageCS ) ;
    public final void rule__RootCS__PackagesAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4846:1: ( ( rulePackageCS ) )
            // InternalMiniOCLCS.g:4847:2: ( rulePackageCS )
            {
            // InternalMiniOCLCS.g:4847:2: ( rulePackageCS )
            // InternalMiniOCLCS.g:4848:3: rulePackageCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRootCSAccess().getPackagesPackageCSParserRuleCall_1_0_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePackageCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRootCSAccess().getPackagesPackageCSParserRuleCall_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RootCS__PackagesAssignment_1_0"


    // $ANTLR start "rule__RootCS__ConstraintsAssignment_1_1"
    // InternalMiniOCLCS.g:4857:1: rule__RootCS__ConstraintsAssignment_1_1 : ( ruleConstraintsDefCS ) ;
    public final void rule__RootCS__ConstraintsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4861:1: ( ( ruleConstraintsDefCS ) )
            // InternalMiniOCLCS.g:4862:2: ( ruleConstraintsDefCS )
            {
            // InternalMiniOCLCS.g:4862:2: ( ruleConstraintsDefCS )
            // InternalMiniOCLCS.g:4863:3: ruleConstraintsDefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRootCSAccess().getConstraintsConstraintsDefCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleConstraintsDefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRootCSAccess().getConstraintsConstraintsDefCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RootCS__ConstraintsAssignment_1_1"


    // $ANTLR start "rule__ImportCS__AliasAssignment_1_0"
    // InternalMiniOCLCS.g:4872:1: rule__ImportCS__AliasAssignment_1_0 : ( RULE_ID ) ;
    public final void rule__ImportCS__AliasAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4876:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:4877:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:4877:2: ( RULE_ID )
            // InternalMiniOCLCS.g:4878:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getAliasIDTerminalRuleCall_1_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getAliasIDTerminalRuleCall_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ImportCS__AliasAssignment_1_0"


    // $ANTLR start "rule__ImportCS__UriAssignment_2"
    // InternalMiniOCLCS.g:4887:1: rule__ImportCS__UriAssignment_2 : ( RULE_STRING ) ;
    public final void rule__ImportCS__UriAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4891:1: ( ( RULE_STRING ) )
            // InternalMiniOCLCS.g:4892:2: ( RULE_STRING )
            {
            // InternalMiniOCLCS.g:4892:2: ( RULE_STRING )
            // InternalMiniOCLCS.g:4893:3: RULE_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getImportCSAccess().getUriSTRINGTerminalRuleCall_2_0()); 
            }
            match(input,RULE_STRING,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getImportCSAccess().getUriSTRINGTerminalRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ImportCS__UriAssignment_2"


    // $ANTLR start "rule__PackageCS__NameAssignment_1"
    // InternalMiniOCLCS.g:4902:1: rule__PackageCS__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__PackageCS__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4906:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:4907:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:4907:2: ( RULE_ID )
            // InternalMiniOCLCS.g:4908:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PackageCS__NameAssignment_1"


    // $ANTLR start "rule__PackageCS__PackagesAssignment_3_0"
    // InternalMiniOCLCS.g:4917:1: rule__PackageCS__PackagesAssignment_3_0 : ( rulePackageCS ) ;
    public final void rule__PackageCS__PackagesAssignment_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4921:1: ( ( rulePackageCS ) )
            // InternalMiniOCLCS.g:4922:2: ( rulePackageCS )
            {
            // InternalMiniOCLCS.g:4922:2: ( rulePackageCS )
            // InternalMiniOCLCS.g:4923:3: rulePackageCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getPackagesPackageCSParserRuleCall_3_0_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePackageCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getPackagesPackageCSParserRuleCall_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PackageCS__PackagesAssignment_3_0"


    // $ANTLR start "rule__PackageCS__ClassesAssignment_3_1"
    // InternalMiniOCLCS.g:4932:1: rule__PackageCS__ClassesAssignment_3_1 : ( ruleClassCS ) ;
    public final void rule__PackageCS__ClassesAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4936:1: ( ( ruleClassCS ) )
            // InternalMiniOCLCS.g:4937:2: ( ruleClassCS )
            {
            // InternalMiniOCLCS.g:4937:2: ( ruleClassCS )
            // InternalMiniOCLCS.g:4938:3: ruleClassCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPackageCSAccess().getClassesClassCSParserRuleCall_3_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleClassCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPackageCSAccess().getClassesClassCSParserRuleCall_3_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PackageCS__ClassesAssignment_3_1"


    // $ANTLR start "rule__ClassCS__NameAssignment_1"
    // InternalMiniOCLCS.g:4947:1: rule__ClassCS__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__ClassCS__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4951:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:4952:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:4952:2: ( RULE_ID )
            // InternalMiniOCLCS.g:4953:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassCS__NameAssignment_1"


    // $ANTLR start "rule__ClassCS__ExtendsAssignment_2_1"
    // InternalMiniOCLCS.g:4962:1: rule__ClassCS__ExtendsAssignment_2_1 : ( rulePathNameCS ) ;
    public final void rule__ClassCS__ExtendsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4966:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:4967:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:4967:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:4968:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getExtendsPathNameCSParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getExtendsPathNameCSParserRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassCS__ExtendsAssignment_2_1"


    // $ANTLR start "rule__ClassCS__PropertiesAssignment_4_0"
    // InternalMiniOCLCS.g:4977:1: rule__ClassCS__PropertiesAssignment_4_0 : ( rulePropertyCS ) ;
    public final void rule__ClassCS__PropertiesAssignment_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4981:1: ( ( rulePropertyCS ) )
            // InternalMiniOCLCS.g:4982:2: ( rulePropertyCS )
            {
            // InternalMiniOCLCS.g:4982:2: ( rulePropertyCS )
            // InternalMiniOCLCS.g:4983:3: rulePropertyCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getPropertiesPropertyCSParserRuleCall_4_0_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePropertyCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getPropertiesPropertyCSParserRuleCall_4_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassCS__PropertiesAssignment_4_0"


    // $ANTLR start "rule__ClassCS__OperationsAssignment_4_1"
    // InternalMiniOCLCS.g:4992:1: rule__ClassCS__OperationsAssignment_4_1 : ( ruleOperationCS ) ;
    public final void rule__ClassCS__OperationsAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:4996:1: ( ( ruleOperationCS ) )
            // InternalMiniOCLCS.g:4997:2: ( ruleOperationCS )
            {
            // InternalMiniOCLCS.g:4997:2: ( ruleOperationCS )
            // InternalMiniOCLCS.g:4998:3: ruleOperationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getClassCSAccess().getOperationsOperationCSParserRuleCall_4_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleOperationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getClassCSAccess().getOperationsOperationCSParserRuleCall_4_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ClassCS__OperationsAssignment_4_1"


    // $ANTLR start "rule__PropertyCS__NameAssignment_1"
    // InternalMiniOCLCS.g:5007:1: rule__PropertyCS__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__PropertyCS__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5011:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5012:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5012:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5013:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PropertyCS__NameAssignment_1"


    // $ANTLR start "rule__PropertyCS__TypeRefAssignment_3"
    // InternalMiniOCLCS.g:5022:1: rule__PropertyCS__TypeRefAssignment_3 : ( rulePathNameCS ) ;
    public final void rule__PropertyCS__TypeRefAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5026:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5027:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5027:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5028:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getTypeRefPathNameCSParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getTypeRefPathNameCSParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PropertyCS__TypeRefAssignment_3"


    // $ANTLR start "rule__PropertyCS__MultiplicityAssignment_4"
    // InternalMiniOCLCS.g:5037:1: rule__PropertyCS__MultiplicityAssignment_4 : ( ruleMultiplicityCS ) ;
    public final void rule__PropertyCS__MultiplicityAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5041:1: ( ( ruleMultiplicityCS ) )
            // InternalMiniOCLCS.g:5042:2: ( ruleMultiplicityCS )
            {
            // InternalMiniOCLCS.g:5042:2: ( ruleMultiplicityCS )
            // InternalMiniOCLCS.g:5043:3: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPropertyCSAccess().getMultiplicityMultiplicityCSParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPropertyCSAccess().getMultiplicityMultiplicityCSParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PropertyCS__MultiplicityAssignment_4"


    // $ANTLR start "rule__MultiplicityCS__OptAssignment_1_0"
    // InternalMiniOCLCS.g:5052:1: rule__MultiplicityCS__OptAssignment_1_0 : ( ( '?' ) ) ;
    public final void rule__MultiplicityCS__OptAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5056:1: ( ( ( '?' ) ) )
            // InternalMiniOCLCS.g:5057:2: ( ( '?' ) )
            {
            // InternalMiniOCLCS.g:5057:2: ( ( '?' ) )
            // InternalMiniOCLCS.g:5058:3: ( '?' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getOptQuestionMarkKeyword_1_0_0()); 
            }
            // InternalMiniOCLCS.g:5059:3: ( '?' )
            // InternalMiniOCLCS.g:5060:4: '?'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getOptQuestionMarkKeyword_1_0_0()); 
            }
            match(input,43,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getOptQuestionMarkKeyword_1_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getOptQuestionMarkKeyword_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__OptAssignment_1_0"


    // $ANTLR start "rule__MultiplicityCS__MultAssignment_1_1"
    // InternalMiniOCLCS.g:5071:1: rule__MultiplicityCS__MultAssignment_1_1 : ( ( '*' ) ) ;
    public final void rule__MultiplicityCS__MultAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5075:1: ( ( ( '*' ) ) )
            // InternalMiniOCLCS.g:5076:2: ( ( '*' ) )
            {
            // InternalMiniOCLCS.g:5076:2: ( ( '*' ) )
            // InternalMiniOCLCS.g:5077:3: ( '*' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getMultAsteriskKeyword_1_1_0()); 
            }
            // InternalMiniOCLCS.g:5078:3: ( '*' )
            // InternalMiniOCLCS.g:5079:4: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getMultAsteriskKeyword_1_1_0()); 
            }
            match(input,44,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getMultAsteriskKeyword_1_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getMultAsteriskKeyword_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__MultAssignment_1_1"


    // $ANTLR start "rule__MultiplicityCS__MandatoryAssignment_1_2"
    // InternalMiniOCLCS.g:5090:1: rule__MultiplicityCS__MandatoryAssignment_1_2 : ( RULE_INT ) ;
    public final void rule__MultiplicityCS__MandatoryAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5094:1: ( ( RULE_INT ) )
            // InternalMiniOCLCS.g:5095:2: ( RULE_INT )
            {
            // InternalMiniOCLCS.g:5095:2: ( RULE_INT )
            // InternalMiniOCLCS.g:5096:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getMandatoryINTTerminalRuleCall_1_2_0()); 
            }
            match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getMandatoryINTTerminalRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__MandatoryAssignment_1_2"


    // $ANTLR start "rule__MultiplicityCS__LowerIntAssignment_1_3_0"
    // InternalMiniOCLCS.g:5105:1: rule__MultiplicityCS__LowerIntAssignment_1_3_0 : ( RULE_INT ) ;
    public final void rule__MultiplicityCS__LowerIntAssignment_1_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5109:1: ( ( RULE_INT ) )
            // InternalMiniOCLCS.g:5110:2: ( RULE_INT )
            {
            // InternalMiniOCLCS.g:5110:2: ( RULE_INT )
            // InternalMiniOCLCS.g:5111:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLowerIntINTTerminalRuleCall_1_3_0_0()); 
            }
            match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getLowerIntINTTerminalRuleCall_1_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__LowerIntAssignment_1_3_0"


    // $ANTLR start "rule__MultiplicityCS__UpperIntAssignment_1_3_2_0"
    // InternalMiniOCLCS.g:5120:1: rule__MultiplicityCS__UpperIntAssignment_1_3_2_0 : ( RULE_INT ) ;
    public final void rule__MultiplicityCS__UpperIntAssignment_1_3_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5124:1: ( ( RULE_INT ) )
            // InternalMiniOCLCS.g:5125:2: ( RULE_INT )
            {
            // InternalMiniOCLCS.g:5125:2: ( RULE_INT )
            // InternalMiniOCLCS.g:5126:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getUpperIntINTTerminalRuleCall_1_3_2_0_0()); 
            }
            match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getUpperIntINTTerminalRuleCall_1_3_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__UpperIntAssignment_1_3_2_0"


    // $ANTLR start "rule__MultiplicityCS__UpperMultAssignment_1_3_2_1"
    // InternalMiniOCLCS.g:5135:1: rule__MultiplicityCS__UpperMultAssignment_1_3_2_1 : ( ( '*' ) ) ;
    public final void rule__MultiplicityCS__UpperMultAssignment_1_3_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5139:1: ( ( ( '*' ) ) )
            // InternalMiniOCLCS.g:5140:2: ( ( '*' ) )
            {
            // InternalMiniOCLCS.g:5140:2: ( ( '*' ) )
            // InternalMiniOCLCS.g:5141:3: ( '*' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getUpperMultAsteriskKeyword_1_3_2_1_0()); 
            }
            // InternalMiniOCLCS.g:5142:3: ( '*' )
            // InternalMiniOCLCS.g:5143:4: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getUpperMultAsteriskKeyword_1_3_2_1_0()); 
            }
            match(input,44,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getUpperMultAsteriskKeyword_1_3_2_1_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getUpperMultAsteriskKeyword_1_3_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__UpperMultAssignment_1_3_2_1"


    // $ANTLR start "rule__OperationCS__NameAssignment_1"
    // InternalMiniOCLCS.g:5154:1: rule__OperationCS__NameAssignment_1 : ( RULE_ID ) ;
    public final void rule__OperationCS__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5158:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5159:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5159:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5160:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getNameIDTerminalRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__NameAssignment_1"


    // $ANTLR start "rule__OperationCS__ParamsAssignment_3_0"
    // InternalMiniOCLCS.g:5169:1: rule__OperationCS__ParamsAssignment_3_0 : ( ruleParameterCS ) ;
    public final void rule__OperationCS__ParamsAssignment_3_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5173:1: ( ( ruleParameterCS ) )
            // InternalMiniOCLCS.g:5174:2: ( ruleParameterCS )
            {
            // InternalMiniOCLCS.g:5174:2: ( ruleParameterCS )
            // InternalMiniOCLCS.g:5175:3: ruleParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getParamsParameterCSParserRuleCall_3_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getParamsParameterCSParserRuleCall_3_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__ParamsAssignment_3_0"


    // $ANTLR start "rule__OperationCS__ParamsAssignment_3_1_1"
    // InternalMiniOCLCS.g:5184:1: rule__OperationCS__ParamsAssignment_3_1_1 : ( ruleParameterCS ) ;
    public final void rule__OperationCS__ParamsAssignment_3_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5188:1: ( ( ruleParameterCS ) )
            // InternalMiniOCLCS.g:5189:2: ( ruleParameterCS )
            {
            // InternalMiniOCLCS.g:5189:2: ( ruleParameterCS )
            // InternalMiniOCLCS.g:5190:3: ruleParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getParamsParameterCSParserRuleCall_3_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getParamsParameterCSParserRuleCall_3_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__ParamsAssignment_3_1_1"


    // $ANTLR start "rule__OperationCS__ResultRefAssignment_6"
    // InternalMiniOCLCS.g:5199:1: rule__OperationCS__ResultRefAssignment_6 : ( rulePathNameCS ) ;
    public final void rule__OperationCS__ResultRefAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5203:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5204:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5204:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5205:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getResultRefPathNameCSParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getResultRefPathNameCSParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__ResultRefAssignment_6"


    // $ANTLR start "rule__OperationCS__BodyAssignment_8"
    // InternalMiniOCLCS.g:5214:1: rule__OperationCS__BodyAssignment_8 : ( ruleExpCS ) ;
    public final void rule__OperationCS__BodyAssignment_8() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5218:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5219:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5219:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5220:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getBodyExpCSParserRuleCall_8_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getBodyExpCSParserRuleCall_8_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__BodyAssignment_8"


    // $ANTLR start "rule__ParameterCS__NameAssignment_0"
    // InternalMiniOCLCS.g:5229:1: rule__ParameterCS__NameAssignment_0 : ( RULE_ID ) ;
    public final void rule__ParameterCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5233:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5234:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5234:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5235:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__NameAssignment_0"


    // $ANTLR start "rule__ParameterCS__TypeRefAssignment_2"
    // InternalMiniOCLCS.g:5244:1: rule__ParameterCS__TypeRefAssignment_2 : ( rulePathNameCS ) ;
    public final void rule__ParameterCS__TypeRefAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5248:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5249:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5249:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5250:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getTypeRefPathNameCSParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getTypeRefPathNameCSParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__TypeRefAssignment_2"


    // $ANTLR start "rule__ConstraintsDefCS__TypeRefAssignment_1"
    // InternalMiniOCLCS.g:5259:1: rule__ConstraintsDefCS__TypeRefAssignment_1 : ( rulePathNameCS ) ;
    public final void rule__ConstraintsDefCS__TypeRefAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5263:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5264:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5264:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5265:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getTypeRefPathNameCSParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getTypeRefPathNameCSParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConstraintsDefCS__TypeRefAssignment_1"


    // $ANTLR start "rule__ConstraintsDefCS__InvariantsAssignment_3"
    // InternalMiniOCLCS.g:5274:1: rule__ConstraintsDefCS__InvariantsAssignment_3 : ( ruleInvariantCS ) ;
    public final void rule__ConstraintsDefCS__InvariantsAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5278:1: ( ( ruleInvariantCS ) )
            // InternalMiniOCLCS.g:5279:2: ( ruleInvariantCS )
            {
            // InternalMiniOCLCS.g:5279:2: ( ruleInvariantCS )
            // InternalMiniOCLCS.g:5280:3: ruleInvariantCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getConstraintsDefCSAccess().getInvariantsInvariantCSParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleInvariantCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getConstraintsDefCSAccess().getInvariantsInvariantCSParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ConstraintsDefCS__InvariantsAssignment_3"


    // $ANTLR start "rule__InvariantCS__ExpAssignment_2"
    // InternalMiniOCLCS.g:5289:1: rule__InvariantCS__ExpAssignment_2 : ( ruleExpCS ) ;
    public final void rule__InvariantCS__ExpAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5293:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5294:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5294:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5295:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvariantCSAccess().getExpExpCSParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvariantCSAccess().getExpExpCSParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvariantCS__ExpAssignment_2"


    // $ANTLR start "rule__EqualityExpCS__OpNameAssignment_1_1"
    // InternalMiniOCLCS.g:5304:1: rule__EqualityExpCS__OpNameAssignment_1_1 : ( ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 ) ) ;
    public final void rule__EqualityExpCS__OpNameAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5308:1: ( ( ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 ) ) )
            // InternalMiniOCLCS.g:5309:2: ( ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 ) )
            {
            // InternalMiniOCLCS.g:5309:2: ( ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 ) )
            // InternalMiniOCLCS.g:5310:3: ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getOpNameAlternatives_1_1_0()); 
            }
            // InternalMiniOCLCS.g:5311:3: ( rule__EqualityExpCS__OpNameAlternatives_1_1_0 )
            // InternalMiniOCLCS.g:5311:4: rule__EqualityExpCS__OpNameAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__EqualityExpCS__OpNameAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getOpNameAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EqualityExpCS__OpNameAssignment_1_1"


    // $ANTLR start "rule__EqualityExpCS__RightAssignment_1_2"
    // InternalMiniOCLCS.g:5319:1: rule__EqualityExpCS__RightAssignment_1_2 : ( ruleCallExpCS ) ;
    public final void rule__EqualityExpCS__RightAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5323:1: ( ( ruleCallExpCS ) )
            // InternalMiniOCLCS.g:5324:2: ( ruleCallExpCS )
            {
            // InternalMiniOCLCS.g:5324:2: ( ruleCallExpCS )
            // InternalMiniOCLCS.g:5325:3: ruleCallExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEqualityExpCSAccess().getRightCallExpCSParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCallExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEqualityExpCSAccess().getRightCallExpCSParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EqualityExpCS__RightAssignment_1_2"


    // $ANTLR start "rule__CallExpCS__OpNameAssignment_1_1"
    // InternalMiniOCLCS.g:5334:1: rule__CallExpCS__OpNameAssignment_1_1 : ( ( rule__CallExpCS__OpNameAlternatives_1_1_0 ) ) ;
    public final void rule__CallExpCS__OpNameAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5338:1: ( ( ( rule__CallExpCS__OpNameAlternatives_1_1_0 ) ) )
            // InternalMiniOCLCS.g:5339:2: ( ( rule__CallExpCS__OpNameAlternatives_1_1_0 ) )
            {
            // InternalMiniOCLCS.g:5339:2: ( ( rule__CallExpCS__OpNameAlternatives_1_1_0 ) )
            // InternalMiniOCLCS.g:5340:3: ( rule__CallExpCS__OpNameAlternatives_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getOpNameAlternatives_1_1_0()); 
            }
            // InternalMiniOCLCS.g:5341:3: ( rule__CallExpCS__OpNameAlternatives_1_1_0 )
            // InternalMiniOCLCS.g:5341:4: rule__CallExpCS__OpNameAlternatives_1_1_0
            {
            pushFollow(FOLLOW_2);
            rule__CallExpCS__OpNameAlternatives_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getOpNameAlternatives_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CallExpCS__OpNameAssignment_1_1"


    // $ANTLR start "rule__CallExpCS__NavExpAssignment_1_2"
    // InternalMiniOCLCS.g:5349:1: rule__CallExpCS__NavExpAssignment_1_2 : ( ruleNavigationExpCS ) ;
    public final void rule__CallExpCS__NavExpAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5353:1: ( ( ruleNavigationExpCS ) )
            // InternalMiniOCLCS.g:5354:2: ( ruleNavigationExpCS )
            {
            // InternalMiniOCLCS.g:5354:2: ( ruleNavigationExpCS )
            // InternalMiniOCLCS.g:5355:3: ruleNavigationExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCallExpCSAccess().getNavExpNavigationExpCSParserRuleCall_1_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleNavigationExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCallExpCSAccess().getNavExpNavigationExpCSParserRuleCall_1_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CallExpCS__NavExpAssignment_1_2"


    // $ANTLR start "rule__CollectExpCS__ItVarAssignment_2_0"
    // InternalMiniOCLCS.g:5364:1: rule__CollectExpCS__ItVarAssignment_2_0 : ( ruleIteratorVarCS ) ;
    public final void rule__CollectExpCS__ItVarAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5368:1: ( ( ruleIteratorVarCS ) )
            // InternalMiniOCLCS.g:5369:2: ( ruleIteratorVarCS )
            {
            // InternalMiniOCLCS.g:5369:2: ( ruleIteratorVarCS )
            // InternalMiniOCLCS.g:5370:3: ruleIteratorVarCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getItVarIteratorVarCSParserRuleCall_2_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIteratorVarCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getItVarIteratorVarCSParserRuleCall_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectExpCS__ItVarAssignment_2_0"


    // $ANTLR start "rule__CollectExpCS__ExpAssignment_3"
    // InternalMiniOCLCS.g:5379:1: rule__CollectExpCS__ExpAssignment_3 : ( ruleExpCS ) ;
    public final void rule__CollectExpCS__ExpAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5383:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5384:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5384:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5385:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectExpCSAccess().getExpExpCSParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectExpCSAccess().getExpExpCSParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectExpCS__ExpAssignment_3"


    // $ANTLR start "rule__IteratorVarCS__ItNameAssignment_0"
    // InternalMiniOCLCS.g:5394:1: rule__IteratorVarCS__ItNameAssignment_0 : ( RULE_ID ) ;
    public final void rule__IteratorVarCS__ItNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5398:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5399:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5399:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5400:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getItNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getItNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IteratorVarCS__ItNameAssignment_0"


    // $ANTLR start "rule__IteratorVarCS__ItTypeAssignment_1_1"
    // InternalMiniOCLCS.g:5409:1: rule__IteratorVarCS__ItTypeAssignment_1_1 : ( rulePathNameCS ) ;
    public final void rule__IteratorVarCS__ItTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5413:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5414:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5414:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5415:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIteratorVarCSAccess().getItTypePathNameCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIteratorVarCSAccess().getItTypePathNameCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IteratorVarCS__ItTypeAssignment_1_1"


    // $ANTLR start "rule__IterateExpCS__ItVarAssignment_2"
    // InternalMiniOCLCS.g:5424:1: rule__IterateExpCS__ItVarAssignment_2 : ( ruleIteratorVarCS ) ;
    public final void rule__IterateExpCS__ItVarAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5428:1: ( ( ruleIteratorVarCS ) )
            // InternalMiniOCLCS.g:5429:2: ( ruleIteratorVarCS )
            {
            // InternalMiniOCLCS.g:5429:2: ( ruleIteratorVarCS )
            // InternalMiniOCLCS.g:5430:3: ruleIteratorVarCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getItVarIteratorVarCSParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleIteratorVarCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getItVarIteratorVarCSParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IterateExpCS__ItVarAssignment_2"


    // $ANTLR start "rule__IterateExpCS__AccVarAssignment_4"
    // InternalMiniOCLCS.g:5439:1: rule__IterateExpCS__AccVarAssignment_4 : ( ruleAccVarCS ) ;
    public final void rule__IterateExpCS__AccVarAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5443:1: ( ( ruleAccVarCS ) )
            // InternalMiniOCLCS.g:5444:2: ( ruleAccVarCS )
            {
            // InternalMiniOCLCS.g:5444:2: ( ruleAccVarCS )
            // InternalMiniOCLCS.g:5445:3: ruleAccVarCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getAccVarAccVarCSParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleAccVarCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getAccVarAccVarCSParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IterateExpCS__AccVarAssignment_4"


    // $ANTLR start "rule__IterateExpCS__ExpAssignment_6"
    // InternalMiniOCLCS.g:5454:1: rule__IterateExpCS__ExpAssignment_6 : ( ruleExpCS ) ;
    public final void rule__IterateExpCS__ExpAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5458:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5459:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5459:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5460:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIterateExpCSAccess().getExpExpCSParserRuleCall_6_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIterateExpCSAccess().getExpExpCSParserRuleCall_6_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IterateExpCS__ExpAssignment_6"


    // $ANTLR start "rule__AccVarCS__AccNameAssignment_0"
    // InternalMiniOCLCS.g:5469:1: rule__AccVarCS__AccNameAssignment_0 : ( RULE_ID ) ;
    public final void rule__AccVarCS__AccNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5473:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5474:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5474:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5475:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AccVarCS__AccNameAssignment_0"


    // $ANTLR start "rule__AccVarCS__AccTypeAssignment_1_1"
    // InternalMiniOCLCS.g:5484:1: rule__AccVarCS__AccTypeAssignment_1_1 : ( rulePathNameCS ) ;
    public final void rule__AccVarCS__AccTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5488:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5489:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5489:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5490:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccTypePathNameCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccTypePathNameCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AccVarCS__AccTypeAssignment_1_1"


    // $ANTLR start "rule__AccVarCS__AccInitExpAssignment_3"
    // InternalMiniOCLCS.g:5499:1: rule__AccVarCS__AccInitExpAssignment_3 : ( ruleExpCS ) ;
    public final void rule__AccVarCS__AccInitExpAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5503:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5504:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5504:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5505:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAccVarCSAccess().getAccInitExpExpCSParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAccVarCSAccess().getAccInitExpExpCSParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AccVarCS__AccInitExpAssignment_3"


    // $ANTLR start "rule__NameExpCS__ExpNameAssignment_0"
    // InternalMiniOCLCS.g:5514:1: rule__NameExpCS__ExpNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__NameExpCS__ExpNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5518:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5519:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5519:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5520:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getExpNamePathNameCSParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getExpNamePathNameCSParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__ExpNameAssignment_0"


    // $ANTLR start "rule__NameExpCS__RoundedBracketsAssignment_1"
    // InternalMiniOCLCS.g:5529:1: rule__NameExpCS__RoundedBracketsAssignment_1 : ( ruleRoundedBracketClauseCS ) ;
    public final void rule__NameExpCS__RoundedBracketsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5533:1: ( ( ruleRoundedBracketClauseCS ) )
            // InternalMiniOCLCS.g:5534:2: ( ruleRoundedBracketClauseCS )
            {
            // InternalMiniOCLCS.g:5534:2: ( ruleRoundedBracketClauseCS )
            // InternalMiniOCLCS.g:5535:3: ruleRoundedBracketClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getRoundedBracketsRoundedBracketClauseCSParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleRoundedBracketClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getRoundedBracketsRoundedBracketClauseCSParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__RoundedBracketsAssignment_1"


    // $ANTLR start "rule__RoundedBracketClauseCS__ArgsAssignment_2_0"
    // InternalMiniOCLCS.g:5544:1: rule__RoundedBracketClauseCS__ArgsAssignment_2_0 : ( ruleExpCS ) ;
    public final void rule__RoundedBracketClauseCS__ArgsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5548:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5549:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5549:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5550:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getArgsExpCSParserRuleCall_2_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getArgsExpCSParserRuleCall_2_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundedBracketClauseCS__ArgsAssignment_2_0"


    // $ANTLR start "rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1"
    // InternalMiniOCLCS.g:5559:1: rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1 : ( ruleExpCS ) ;
    public final void rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5563:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5564:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5564:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5565:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundedBracketClauseCSAccess().getArgsExpCSParserRuleCall_2_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundedBracketClauseCSAccess().getArgsExpCSParserRuleCall_2_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundedBracketClauseCS__ArgsAssignment_2_1_1"


    // $ANTLR start "rule__IntLiteralExpCS__IntSymbolAssignment"
    // InternalMiniOCLCS.g:5574:1: rule__IntLiteralExpCS__IntSymbolAssignment : ( RULE_INT ) ;
    public final void rule__IntLiteralExpCS__IntSymbolAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5578:1: ( ( RULE_INT ) )
            // InternalMiniOCLCS.g:5579:2: ( RULE_INT )
            {
            // InternalMiniOCLCS.g:5579:2: ( RULE_INT )
            // InternalMiniOCLCS.g:5580:3: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIntLiteralExpCSAccess().getIntSymbolINTTerminalRuleCall_0()); 
            }
            match(input,RULE_INT,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIntLiteralExpCSAccess().getIntSymbolINTTerminalRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IntLiteralExpCS__IntSymbolAssignment"


    // $ANTLR start "rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0"
    // InternalMiniOCLCS.g:5589:1: rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0 : ( ( 'true' ) ) ;
    public final void rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5593:1: ( ( ( 'true' ) ) )
            // InternalMiniOCLCS.g:5594:2: ( ( 'true' ) )
            {
            // InternalMiniOCLCS.g:5594:2: ( ( 'true' ) )
            // InternalMiniOCLCS.g:5595:3: ( 'true' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getBoolSymbolTrueKeyword_1_0_0()); 
            }
            // InternalMiniOCLCS.g:5596:3: ( 'true' )
            // InternalMiniOCLCS.g:5597:4: 'true'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getBoolSymbolTrueKeyword_1_0_0()); 
            }
            match(input,45,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getBoolSymbolTrueKeyword_1_0_0()); 
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getBoolSymbolTrueKeyword_1_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__BoolSymbolAssignment_1_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__KindAssignment_0"
    // InternalMiniOCLCS.g:5608:1: rule__CollectionLiteralExpCS__KindAssignment_0 : ( ruleCollectionKindCS ) ;
    public final void rule__CollectionLiteralExpCS__KindAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5612:1: ( ( ruleCollectionKindCS ) )
            // InternalMiniOCLCS.g:5613:2: ( ruleCollectionKindCS )
            {
            // InternalMiniOCLCS.g:5613:2: ( ruleCollectionKindCS )
            // InternalMiniOCLCS.g:5614:3: ruleCollectionKindCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getKindCollectionKindCSEnumRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCollectionKindCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getKindCollectionKindCSEnumRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__KindAssignment_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__PartsAssignment_2"
    // InternalMiniOCLCS.g:5623:1: rule__CollectionLiteralExpCS__PartsAssignment_2 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__PartsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5627:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalMiniOCLCS.g:5628:2: ( ruleCollectionLiteralPartCS )
            {
            // InternalMiniOCLCS.g:5628:2: ( ruleCollectionLiteralPartCS )
            // InternalMiniOCLCS.g:5629:3: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getPartsCollectionLiteralPartCSParserRuleCall_2_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getPartsCollectionLiteralPartCSParserRuleCall_2_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__PartsAssignment_2"


    // $ANTLR start "rule__CollectionLiteralPartCS__FirstAssignment_0"
    // InternalMiniOCLCS.g:5638:1: rule__CollectionLiteralPartCS__FirstAssignment_0 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__FirstAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5642:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5643:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5643:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5644:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFirstExpCSParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getFirstExpCSParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__FirstAssignment_0"


    // $ANTLR start "rule__CollectionLiteralPartCS__LastAssignment_1_1"
    // InternalMiniOCLCS.g:5653:1: rule__CollectionLiteralPartCS__LastAssignment_1_1 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__LastAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5657:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5658:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5658:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5659:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getLastExpCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getLastExpCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__LastAssignment_1_1"


    // $ANTLR start "rule__LetExpCS__LetVarsAssignment_1"
    // InternalMiniOCLCS.g:5668:1: rule__LetExpCS__LetVarsAssignment_1 : ( ruleLetVarCS ) ;
    public final void rule__LetExpCS__LetVarsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5672:1: ( ( ruleLetVarCS ) )
            // InternalMiniOCLCS.g:5673:2: ( ruleLetVarCS )
            {
            // InternalMiniOCLCS.g:5673:2: ( ruleLetVarCS )
            // InternalMiniOCLCS.g:5674:3: ruleLetVarCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetVarsLetVarCSParserRuleCall_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleLetVarCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetVarsLetVarCSParserRuleCall_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__LetVarsAssignment_1"


    // $ANTLR start "rule__LetExpCS__LetVarsAssignment_2_1"
    // InternalMiniOCLCS.g:5683:1: rule__LetExpCS__LetVarsAssignment_2_1 : ( ruleLetVarCS ) ;
    public final void rule__LetExpCS__LetVarsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5687:1: ( ( ruleLetVarCS ) )
            // InternalMiniOCLCS.g:5688:2: ( ruleLetVarCS )
            {
            // InternalMiniOCLCS.g:5688:2: ( ruleLetVarCS )
            // InternalMiniOCLCS.g:5689:3: ruleLetVarCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetVarsLetVarCSParserRuleCall_2_1_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleLetVarCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetVarsLetVarCSParserRuleCall_2_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__LetVarsAssignment_2_1"


    // $ANTLR start "rule__LetExpCS__InExpAssignment_4"
    // InternalMiniOCLCS.g:5698:1: rule__LetExpCS__InExpAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetExpCS__InExpAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5702:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5703:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5703:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5704:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInExpExpCSParserRuleCall_4_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getInExpExpCSParserRuleCall_4_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__InExpAssignment_4"


    // $ANTLR start "rule__LetVarCS__NameAssignment_0"
    // InternalMiniOCLCS.g:5713:1: rule__LetVarCS__NameAssignment_0 : ( RULE_ID ) ;
    public final void rule__LetVarCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5717:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5718:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5718:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5719:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getNameIDTerminalRuleCall_0_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getNameIDTerminalRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__NameAssignment_0"


    // $ANTLR start "rule__LetVarCS__TypeRefAssignment_1_1"
    // InternalMiniOCLCS.g:5728:1: rule__LetVarCS__TypeRefAssignment_1_1 : ( rulePathNameCS ) ;
    public final void rule__LetVarCS__TypeRefAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5732:1: ( ( rulePathNameCS ) )
            // InternalMiniOCLCS.g:5733:2: ( rulePathNameCS )
            {
            // InternalMiniOCLCS.g:5733:2: ( rulePathNameCS )
            // InternalMiniOCLCS.g:5734:3: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getTypeRefPathNameCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getTypeRefPathNameCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__TypeRefAssignment_1_1"


    // $ANTLR start "rule__LetVarCS__InitExpAssignment_3"
    // InternalMiniOCLCS.g:5743:1: rule__LetVarCS__InitExpAssignment_3 : ( ruleExpCS ) ;
    public final void rule__LetVarCS__InitExpAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5747:1: ( ( ruleExpCS ) )
            // InternalMiniOCLCS.g:5748:2: ( ruleExpCS )
            {
            // InternalMiniOCLCS.g:5748:2: ( ruleExpCS )
            // InternalMiniOCLCS.g:5749:3: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVarCSAccess().getInitExpExpCSParserRuleCall_3_0()); 
            }
            pushFollow(FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVarCSAccess().getInitExpExpCSParserRuleCall_3_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVarCS__InitExpAssignment_3"


    // $ANTLR start "rule__PathNameCS__PathElementsAssignment_0"
    // InternalMiniOCLCS.g:5758:1: rule__PathNameCS__PathElementsAssignment_0 : ( rulePathElementCS ) ;
    public final void rule__PathNameCS__PathElementsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5762:1: ( ( rulePathElementCS ) )
            // InternalMiniOCLCS.g:5763:2: ( rulePathElementCS )
            {
            // InternalMiniOCLCS.g:5763:2: ( rulePathElementCS )
            // InternalMiniOCLCS.g:5764:3: rulePathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getPathElementsPathElementCSParserRuleCall_0_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getPathElementsPathElementCSParserRuleCall_0_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__PathElementsAssignment_0"


    // $ANTLR start "rule__PathNameCS__PathElementsAssignment_1_1"
    // InternalMiniOCLCS.g:5773:1: rule__PathNameCS__PathElementsAssignment_1_1 : ( rulePathElementCS ) ;
    public final void rule__PathNameCS__PathElementsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5777:1: ( ( rulePathElementCS ) )
            // InternalMiniOCLCS.g:5778:2: ( rulePathElementCS )
            {
            // InternalMiniOCLCS.g:5778:2: ( rulePathElementCS )
            // InternalMiniOCLCS.g:5779:3: rulePathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getPathElementsPathElementCSParserRuleCall_1_1_0()); 
            }
            pushFollow(FOLLOW_2);
            rulePathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getPathElementsPathElementCSParserRuleCall_1_1_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__PathElementsAssignment_1_1"


    // $ANTLR start "rule__PathElementCS__ElementNameAssignment"
    // InternalMiniOCLCS.g:5788:1: rule__PathElementCS__ElementNameAssignment : ( RULE_ID ) ;
    public final void rule__PathElementCS__ElementNameAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalMiniOCLCS.g:5792:1: ( ( RULE_ID ) )
            // InternalMiniOCLCS.g:5793:2: ( RULE_ID )
            {
            // InternalMiniOCLCS.g:5793:2: ( RULE_ID )
            // InternalMiniOCLCS.g:5794:3: RULE_ID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathElementCSAccess().getElementNameIDTerminalRuleCall_0()); 
            }
            match(input,RULE_ID,FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathElementCSAccess().getElementNameIDTerminalRuleCall_0()); 
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathElementCS__ElementNameAssignment"

    // $ANTLR start synpred28_InternalMiniOCLCS
    public final void synpred28_InternalMiniOCLCS_fragment() throws RecognitionException {   
        // InternalMiniOCLCS.g:2820:3: ( rule__EqualityExpCS__Group_1__0 )
        // InternalMiniOCLCS.g:2820:3: rule__EqualityExpCS__Group_1__0
        {
        pushFollow(FOLLOW_2);
        rule__EqualityExpCS__Group_1__0();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred28_InternalMiniOCLCS

    // $ANTLR start synpred29_InternalMiniOCLCS
    public final void synpred29_InternalMiniOCLCS_fragment() throws RecognitionException {   
        // InternalMiniOCLCS.g:2955:3: ( rule__CallExpCS__Group_1__0 )
        // InternalMiniOCLCS.g:2955:3: rule__CallExpCS__Group_1__0
        {
        pushFollow(FOLLOW_2);
        rule__CallExpCS__Group_1__0();

        state._fsp--;
        if (state.failed) return ;

        }
    }
    // $ANTLR end synpred29_InternalMiniOCLCS

    // Delegated rules

    public final boolean synpred28_InternalMiniOCLCS() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred28_InternalMiniOCLCS_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 synpred29_InternalMiniOCLCS() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred29_InternalMiniOCLCS_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 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[]{0x0000000200100000L});
    public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x0000000000020002L});
    public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x0000000200100002L});
    public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x0000000000000010L});
    public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000040000L});
    public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x0000000000080000L});
    public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000200000L});
    public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000D00000L});
    public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x0000000000900002L});
    public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000001200000L});
    public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000022400000L});
    public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x0000000022000002L});
    public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000004040000L});
    public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x0000180000000040L});
    public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x0000000008000000L});
    public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x0000000010000000L});
    public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000100000000040L});
    public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000040000000L});
    public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000080000010L});
    public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x0000000000001000L});
    public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x0000218800010850L});
    public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x0000000100000000L});
    public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x0000000100000002L});
    public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x0000000400400000L});
    public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000400000002L});
    public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000003000L});
    public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x0000000000003002L});
    public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x000000000000C000L});
    public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x000000000000C002L});
    public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x0000005000000010L});
    public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000800000000L});
    public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000080000000L});
    public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000002000000000L});
    public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x0000000000081000L});
    public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000218880010850L});
    public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x0000200000010000L});
    public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000008000000000L});
    public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000218800410850L});
    public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000218800010852L});
    public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x0000020100000000L});
    public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000040000000000L});
    public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000040000000002L});

}