package org.eclipse.qvtd.xtext.qvtbase.ui.contentassist.antlr.internal;

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


import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
/*******************************************************************************
 * Copyright (c) 2011, 2020 Willink Transformations and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v2.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v20.html
 *
 * Contributors:
 *     E.D.Willink - initial API and implementation
 *******************************************************************************/
@SuppressWarnings("all")
public class InternalQVTbaseParser extends AbstractInternalContentAssistParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_INT", "RULE_SINGLE_QUOTED_STRING", "RULE_SIMPLE_ID", "RULE_ESCAPED_ID", "RULE_UNQUOTED_STRING", "RULE_ESCAPED_CHARACTER", "RULE_LETTER_CHARACTER", "RULE_DOUBLE_QUOTED_STRING", "RULE_ML_SINGLE_QUOTED_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "';'", "'!serializable'", "'-'", "'not'", "'not2'", "'*'", "'/'", "'+'", "'>'", "'<'", "'>='", "'<='", "'='", "'<>'", "'and'", "'and2'", "'implies'", "'implies2'", "'or'", "'or2'", "'xor'", "'xor2'", "'.'", "'->'", "'?.'", "'?->'", "'Map'", "'Tuple'", "'Boolean'", "'Integer'", "'Real'", "'String'", "'UnlimitedNatural'", "'OclAny'", "'OclInvalid'", "'OclVoid'", "'Set'", "'Bag'", "'Sequence'", "'Collection'", "'OrderedSet'", "'|?'", "'?'", "'attribute'", "':'", "'{'", "'}'", "','", "'initial'", "'derivation'", "'datatype'", "'enum'", "'literal'", "'operation'", "'('", "')'", "'throws'", "'body'", "'property'", "'#'", "'iterates'", "'class'", "'extends'", "'..'", "'++'", "'Lambda'", "'<-'", "'invalid'", "'null'", "'pre'", "'['", "']'", "'in'", "'if'", "'then'", "'else'", "'endif'", "'elseif'", "'let'", "'self'", "'::'", "'&&'", "'static'", "'definition'", "'derived'", "'!derived'", "'id'", "'!id'", "'ordered'", "'!ordered'", "'readonly'", "'!readonly'", "'transient'", "'!transient'", "'unique'", "'!unique'", "'unsettable'", "'!unsettable'", "'volatile'", "'!volatile'", "'primitive'", "'serializable'", "'composes'", "'!composes'", "'resolve'", "'!resolve'", "'input'", "'output'", "'via'", "'abstract'", "'interface'", "'true'", "'false'", "'@'", "'|'", "'|1'"
    };
    public static final int T__50=50;
    public static final int T__59=59;
    public static final int T__55=55;
    public static final int T__56=56;
    public static final int T__57=57;
    public static final int T__58=58;
    public static final int T__51=51;
    public static final int T__52=52;
    public static final int T__53=53;
    public static final int T__54=54;
    public static final int T__132=132;
    public static final int T__60=60;
    public static final int T__61=61;
    public static final int T__131=131;
    public static final int T__130=130;
    public static final int RULE_INT=4;
    public static final int T__66=66;
    public static final int RULE_ML_COMMENT=13;
    public static final int T__67=67;
    public static final int T__129=129;
    public static final int T__68=68;
    public static final int T__69=69;
    public static final int T__62=62;
    public static final int T__126=126;
    public static final int T__63=63;
    public static final int T__125=125;
    public static final int T__64=64;
    public static final int T__128=128;
    public static final int T__65=65;
    public static final int T__127=127;
    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 T__30=30;
    public static final int T__31=31;
    public static final int T__32=32;
    public static final int RULE_SINGLE_QUOTED_STRING=5;
    public static final int T__48=48;
    public static final int T__49=49;
    public static final int RULE_DOUBLE_QUOTED_STRING=11;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int T__46=46;
    public static final int T__47=47;
    public static final int RULE_ESCAPED_ID=7;
    public static final int T__40=40;
    public static final int T__41=41;
    public static final int T__42=42;
    public static final int T__43=43;
    public static final int T__91=91;
    public static final int T__100=100;
    public static final int T__92=92;
    public static final int T__93=93;
    public static final int T__102=102;
    public static final int T__94=94;
    public static final int T__101=101;
    public static final int T__90=90;
    public static final int RULE_LETTER_CHARACTER=10;
    public static final int T__19=19;
    public static final int T__17=17;
    public static final int T__18=18;
    public static final int T__99=99;
    public static final int RULE_ESCAPED_CHARACTER=9;
    public static final int T__95=95;
    public static final int RULE_ML_SINGLE_QUOTED_STRING=12;
    public static final int T__96=96;
    public static final int T__97=97;
    public static final int T__98=98;
    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 T__29=29;
    public static final int T__22=22;
    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 T__122=122;
    public static final int T__70=70;
    public static final int T__121=121;
    public static final int T__71=71;
    public static final int T__124=124;
    public static final int T__72=72;
    public static final int T__123=123;
    public static final int T__120=120;
    public static final int RULE_UNQUOTED_STRING=8;
    public static final int RULE_SL_COMMENT=14;
    public static final int T__77=77;
    public static final int T__119=119;
    public static final int T__78=78;
    public static final int T__118=118;
    public static final int T__79=79;
    public static final int T__73=73;
    public static final int T__115=115;
    public static final int EOF=-1;
    public static final int T__74=74;
    public static final int T__114=114;
    public static final int T__75=75;
    public static final int T__117=117;
    public static final int T__76=76;
    public static final int T__116=116;
    public static final int T__80=80;
    public static final int T__111=111;
    public static final int T__81=81;
    public static final int T__110=110;
    public static final int T__82=82;
    public static final int T__113=113;
    public static final int RULE_SIMPLE_ID=6;
    public static final int T__83=83;
    public static final int T__112=112;
    public static final int RULE_WS=15;
    public static final int RULE_ANY_OTHER=16;
    public static final int T__88=88;
    public static final int T__108=108;
    public static final int T__89=89;
    public static final int T__107=107;
    public static final int T__109=109;
    public static final int T__84=84;
    public static final int T__104=104;
    public static final int T__85=85;
    public static final int T__103=103;
    public static final int T__86=86;
    public static final int T__106=106;
    public static final int T__87=87;
    public static final int T__105=105;

    // delegates
    // delegators


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

        }


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


     	private QVTbaseGrammarAccess grammarAccess;

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

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

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


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

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

            }

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


    // $ANTLR start "ruleAttributeCS"
    // InternalQVTbase.g:77:1: ruleAttributeCS : ( ( rule__AttributeCS__Group__0 ) ) ;
    public final void ruleAttributeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:81:2: ( ( ( rule__AttributeCS__Group__0 ) ) )
            // InternalQVTbase.g:82:1: ( ( rule__AttributeCS__Group__0 ) )
            {
            // InternalQVTbase.g:82:1: ( ( rule__AttributeCS__Group__0 ) )
            // InternalQVTbase.g:83:1: ( rule__AttributeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup());
            }
            // InternalQVTbase.g:84:1: ( rule__AttributeCS__Group__0 )
            // InternalQVTbase.g:84:2: rule__AttributeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleCompoundTargetElementCS"
    // InternalQVTbase.g:107:1: ruleCompoundTargetElementCS : ( ( rule__CompoundTargetElementCS__Group__0 ) ) ;
    public final void ruleCompoundTargetElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:111:2: ( ( ( rule__CompoundTargetElementCS__Group__0 ) ) )
            // InternalQVTbase.g:112:1: ( ( rule__CompoundTargetElementCS__Group__0 ) )
            {
            // InternalQVTbase.g:112:1: ( ( rule__CompoundTargetElementCS__Group__0 ) )
            // InternalQVTbase.g:113:1: ( rule__CompoundTargetElementCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getGroup());
            }
            // InternalQVTbase.g:114:1: ( rule__CompoundTargetElementCS__Group__0 )
            // InternalQVTbase.g:114:2: rule__CompoundTargetElementCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CompoundTargetElementCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleDataTypeCS"
    // InternalQVTbase.g:135:1: ruleDataTypeCS : ( ( rule__DataTypeCS__Group__0 ) ) ;
    public final void ruleDataTypeCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:139:2: ( ( ( rule__DataTypeCS__Group__0 ) ) )
            // InternalQVTbase.g:140:1: ( ( rule__DataTypeCS__Group__0 ) )
            {
            // InternalQVTbase.g:140:1: ( ( rule__DataTypeCS__Group__0 ) )
            // InternalQVTbase.g:141:1: ( rule__DataTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getGroup());
            }
            // InternalQVTbase.g:142:1: ( rule__DataTypeCS__Group__0 )
            // InternalQVTbase.g:142:2: rule__DataTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleEnumerationCS"
    // InternalQVTbase.g:163:1: ruleEnumerationCS : ( ( rule__EnumerationCS__Group__0 ) ) ;
    public final void ruleEnumerationCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:167:2: ( ( ( rule__EnumerationCS__Group__0 ) ) )
            // InternalQVTbase.g:168:1: ( ( rule__EnumerationCS__Group__0 ) )
            {
            // InternalQVTbase.g:168:1: ( ( rule__EnumerationCS__Group__0 ) )
            // InternalQVTbase.g:169:1: ( rule__EnumerationCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getGroup());
            }
            // InternalQVTbase.g:170:1: ( rule__EnumerationCS__Group__0 )
            // InternalQVTbase.g:170:2: rule__EnumerationCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleEnumerationLiteralCS"
    // InternalQVTbase.g:191:1: ruleEnumerationLiteralCS : ( ( rule__EnumerationLiteralCS__Group__0 ) ) ;
    public final void ruleEnumerationLiteralCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:195:2: ( ( ( rule__EnumerationLiteralCS__Group__0 ) ) )
            // InternalQVTbase.g:196:1: ( ( rule__EnumerationLiteralCS__Group__0 ) )
            {
            // InternalQVTbase.g:196:1: ( ( rule__EnumerationLiteralCS__Group__0 ) )
            // InternalQVTbase.g:197:1: ( rule__EnumerationLiteralCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getGroup());
            }
            // InternalQVTbase.g:198:1: ( rule__EnumerationLiteralCS__Group__0 )
            // InternalQVTbase.g:198:2: rule__EnumerationLiteralCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:223:2: ( ( ( rule__OperationCS__Group__0 ) ) )
            // InternalQVTbase.g:224:1: ( ( rule__OperationCS__Group__0 ) )
            {
            // InternalQVTbase.g:224:1: ( ( rule__OperationCS__Group__0 ) )
            // InternalQVTbase.g:225:1: ( rule__OperationCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup());
            }
            // InternalQVTbase.g:226:1: ( rule__OperationCS__Group__0 )
            // InternalQVTbase.g:226:2: rule__OperationCS__Group__0
            {
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:238:1: entryRuleParameterCS : ruleParameterCS EOF ;
    public final void entryRuleParameterCS() throws RecognitionException {
        try {
            // InternalQVTbase.g:239:1: ( ruleParameterCS EOF )
            // InternalQVTbase.g:240:1: ruleParameterCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParameterCS();

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:251:2: ( ( ( rule__ParameterCS__Group__0 ) ) )
            // InternalQVTbase.g:252:1: ( ( rule__ParameterCS__Group__0 ) )
            {
            // InternalQVTbase.g:252:1: ( ( rule__ParameterCS__Group__0 ) )
            // InternalQVTbase.g:253:1: ( rule__ParameterCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup());
            }
            // InternalQVTbase.g:254:1: ( rule__ParameterCS__Group__0 )
            // InternalQVTbase.g:254:2: rule__ParameterCS__Group__0
            {
            pushFollow(FollowSets000.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 "entryRuleReferenceCS"
    // InternalQVTbase.g:266:1: entryRuleReferenceCS : ruleReferenceCS EOF ;
    public final void entryRuleReferenceCS() throws RecognitionException {
        try {
            // InternalQVTbase.g:267:1: ( ruleReferenceCS EOF )
            // InternalQVTbase.g:268:1: ruleReferenceCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleReferenceCS();

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

            }

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


    // $ANTLR start "ruleReferenceCS"
    // InternalQVTbase.g:275:1: ruleReferenceCS : ( ( rule__ReferenceCS__Group__0 ) ) ;
    public final void ruleReferenceCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:279:2: ( ( ( rule__ReferenceCS__Group__0 ) ) )
            // InternalQVTbase.g:280:1: ( ( rule__ReferenceCS__Group__0 ) )
            {
            // InternalQVTbase.g:280:1: ( ( rule__ReferenceCS__Group__0 ) )
            // InternalQVTbase.g:281:1: ( rule__ReferenceCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup());
            }
            // InternalQVTbase.g:282:1: ( rule__ReferenceCS__Group__0 )
            // InternalQVTbase.g:282:2: rule__ReferenceCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleSimpleTargetElementCS"
    // InternalQVTbase.g:303:1: ruleSimpleTargetElementCS : ( ( rule__SimpleTargetElementCS__Group__0 ) ) ;
    public final void ruleSimpleTargetElementCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:307:2: ( ( ( rule__SimpleTargetElementCS__Group__0 ) ) )
            // InternalQVTbase.g:308:1: ( ( rule__SimpleTargetElementCS__Group__0 ) )
            {
            // InternalQVTbase.g:308:1: ( ( rule__SimpleTargetElementCS__Group__0 ) )
            // InternalQVTbase.g:309:1: ( rule__SimpleTargetElementCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getGroup());
            }
            // InternalQVTbase.g:310:1: ( rule__SimpleTargetElementCS__Group__0 )
            // InternalQVTbase.g:310:2: rule__SimpleTargetElementCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleSpecificationCS"
    // InternalQVTbase.g:331:1: ruleSpecificationCS : ( ( rule__SpecificationCS__Alternatives ) ) ;
    public final void ruleSpecificationCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:335:2: ( ( ( rule__SpecificationCS__Alternatives ) ) )
            // InternalQVTbase.g:336:1: ( ( rule__SpecificationCS__Alternatives ) )
            {
            // InternalQVTbase.g:336:1: ( ( rule__SpecificationCS__Alternatives ) )
            // InternalQVTbase.g:337:1: ( rule__SpecificationCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSpecificationCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:338:1: ( rule__SpecificationCS__Alternatives )
            // InternalQVTbase.g:338:2: rule__SpecificationCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SpecificationCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleStructuredClassCS"
    // InternalQVTbase.g:359:1: ruleStructuredClassCS : ( ( rule__StructuredClassCS__Group__0 ) ) ;
    public final void ruleStructuredClassCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:363:2: ( ( ( rule__StructuredClassCS__Group__0 ) ) )
            // InternalQVTbase.g:364:1: ( ( rule__StructuredClassCS__Group__0 ) )
            {
            // InternalQVTbase.g:364:1: ( ( rule__StructuredClassCS__Group__0 ) )
            // InternalQVTbase.g:365:1: ( rule__StructuredClassCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getGroup());
            }
            // InternalQVTbase.g:366:1: ( rule__StructuredClassCS__Group__0 )
            // InternalQVTbase.g:366:2: rule__StructuredClassCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleTypedMultiplicityRefCS"
    // InternalQVTbase.g:380:1: entryRuleTypedMultiplicityRefCS : ruleTypedMultiplicityRefCS EOF ;
    public final void entryRuleTypedMultiplicityRefCS() throws RecognitionException {
        try {
            // InternalQVTbase.g:381:1: ( ruleTypedMultiplicityRefCS EOF )
            // InternalQVTbase.g:382:1: ruleTypedMultiplicityRefCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedMultiplicityRefCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypedMultiplicityRefCS();

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

            }

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


    // $ANTLR start "ruleTypedMultiplicityRefCS"
    // InternalQVTbase.g:389:1: ruleTypedMultiplicityRefCS : ( ( rule__TypedMultiplicityRefCS__Group__0 ) ) ;
    public final void ruleTypedMultiplicityRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:393:2: ( ( ( rule__TypedMultiplicityRefCS__Group__0 ) ) )
            // InternalQVTbase.g:394:1: ( ( rule__TypedMultiplicityRefCS__Group__0 ) )
            {
            // InternalQVTbase.g:394:1: ( ( rule__TypedMultiplicityRefCS__Group__0 ) )
            // InternalQVTbase.g:395:1: ( rule__TypedMultiplicityRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedMultiplicityRefCSAccess().getGroup());
            }
            // InternalQVTbase.g:396:1: ( rule__TypedMultiplicityRefCS__Group__0 )
            // InternalQVTbase.g:396:2: rule__TypedMultiplicityRefCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedMultiplicityRefCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleTypedRefCS"
    // InternalQVTbase.g:417:1: ruleTypedRefCS : ( ( rule__TypedRefCS__Alternatives ) ) ;
    public final void ruleTypedRefCS() throws RecognitionException {

        		int stackSize = keepStackSize();

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

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleStructuralFeatureCS"
    // InternalQVTbase.g:436:1: entryRuleStructuralFeatureCS : ruleStructuralFeatureCS EOF ;
    public final void entryRuleStructuralFeatureCS() throws RecognitionException {
        try {
            // InternalQVTbase.g:437:1: ( ruleStructuralFeatureCS EOF )
            // InternalQVTbase.g:438:1: ruleStructuralFeatureCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuralFeatureCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleStructuralFeatureCS();

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

            }

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


    // $ANTLR start "ruleStructuralFeatureCS"
    // InternalQVTbase.g:445:1: ruleStructuralFeatureCS : ( ( rule__StructuralFeatureCS__Alternatives ) ) ;
    public final void ruleStructuralFeatureCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:449:2: ( ( ( rule__StructuralFeatureCS__Alternatives ) ) )
            // InternalQVTbase.g:450:1: ( ( rule__StructuralFeatureCS__Alternatives ) )
            {
            // InternalQVTbase.g:450:1: ( ( rule__StructuralFeatureCS__Alternatives ) )
            // InternalQVTbase.g:451:1: ( rule__StructuralFeatureCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuralFeatureCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:452:1: ( rule__StructuralFeatureCS__Alternatives )
            // InternalQVTbase.g:452:2: rule__StructuralFeatureCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuralFeatureCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEnumerationLiteralName"
    // InternalQVTbase.g:464:1: entryRuleEnumerationLiteralName : ruleEnumerationLiteralName EOF ;
    public final void entryRuleEnumerationLiteralName() throws RecognitionException {
        try {
            // InternalQVTbase.g:465:1: ( ruleEnumerationLiteralName EOF )
            // InternalQVTbase.g:466:1: ruleEnumerationLiteralName EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralNameRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEnumerationLiteralName();

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

            }

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


    // $ANTLR start "ruleEnumerationLiteralName"
    // InternalQVTbase.g:473:1: ruleEnumerationLiteralName : ( ruleEssentialOCLUnrestrictedName ) ;
    public final void ruleEnumerationLiteralName() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:477:2: ( ( ruleEssentialOCLUnrestrictedName ) )
            // InternalQVTbase.g:478:1: ( ruleEssentialOCLUnrestrictedName )
            {
            // InternalQVTbase.g:478:1: ( ruleEssentialOCLUnrestrictedName )
            // InternalQVTbase.g:479:1: ruleEssentialOCLUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnrestrictedName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


    // $ANTLR start "ruleSIGNED"
    // InternalQVTbase.g:503:1: ruleSIGNED : ( ( rule__SIGNED__Group__0 ) ) ;
    public final void ruleSIGNED() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:507:2: ( ( ( rule__SIGNED__Group__0 ) ) )
            // InternalQVTbase.g:508:1: ( ( rule__SIGNED__Group__0 ) )
            {
            // InternalQVTbase.g:508:1: ( ( rule__SIGNED__Group__0 ) )
            // InternalQVTbase.g:509:1: ( rule__SIGNED__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSIGNEDAccess().getGroup());
            }
            // InternalQVTbase.g:510:1: ( rule__SIGNED__Group__0 )
            // InternalQVTbase.g:510:2: rule__SIGNED__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SIGNED__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:539:2: ( ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) ) )
            // InternalQVTbase.g:540:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            {
            // InternalQVTbase.g:540:1: ( ( rule__EssentialOCLUnaryOperatorName__Alternatives ) )
            // InternalQVTbase.g:541:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getAlternatives());
            }
            // InternalQVTbase.g:542:1: ( rule__EssentialOCLUnaryOperatorName__Alternatives )
            // InternalQVTbase.g:542:2: rule__EssentialOCLUnaryOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLUnaryOperatorName__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:567:2: ( ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) ) )
            // InternalQVTbase.g:568:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            {
            // InternalQVTbase.g:568:1: ( ( rule__EssentialOCLInfixOperatorName__Alternatives ) )
            // InternalQVTbase.g:569:1: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAlternatives());
            }
            // InternalQVTbase.g:570:1: ( rule__EssentialOCLInfixOperatorName__Alternatives )
            // InternalQVTbase.g:570:2: rule__EssentialOCLInfixOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLInfixOperatorName__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:595:2: ( ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) ) )
            // InternalQVTbase.g:596:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            {
            // InternalQVTbase.g:596:1: ( ( rule__EssentialOCLNavigationOperatorName__Alternatives ) )
            // InternalQVTbase.g:597:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getAlternatives());
            }
            // InternalQVTbase.g:598:1: ( rule__EssentialOCLNavigationOperatorName__Alternatives )
            // InternalQVTbase.g:598:2: rule__EssentialOCLNavigationOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLNavigationOperatorName__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:623:2: ( ( ( rule__BinaryOperatorName__Alternatives ) ) )
            // InternalQVTbase.g:624:1: ( ( rule__BinaryOperatorName__Alternatives ) )
            {
            // InternalQVTbase.g:624:1: ( ( rule__BinaryOperatorName__Alternatives ) )
            // InternalQVTbase.g:625:1: ( rule__BinaryOperatorName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBinaryOperatorNameAccess().getAlternatives());
            }
            // InternalQVTbase.g:626:1: ( rule__BinaryOperatorName__Alternatives )
            // InternalQVTbase.g:626:2: rule__BinaryOperatorName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__BinaryOperatorName__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:651:2: ( ( ruleEssentialOCLInfixOperatorName ) )
            // InternalQVTbase.g:652:1: ( ruleEssentialOCLInfixOperatorName )
            {
            // InternalQVTbase.g:652:1: ( ruleEssentialOCLInfixOperatorName )
            // InternalQVTbase.g:653:1: ruleEssentialOCLInfixOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInfixOperatorNameAccess().getEssentialOCLInfixOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLInfixOperatorName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:679:2: ( ( ruleEssentialOCLNavigationOperatorName ) )
            // InternalQVTbase.g:680:1: ( ruleEssentialOCLNavigationOperatorName )
            {
            // InternalQVTbase.g:680:1: ( ruleEssentialOCLNavigationOperatorName )
            // InternalQVTbase.g:681:1: ruleEssentialOCLNavigationOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigationOperatorNameAccess().getEssentialOCLNavigationOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLNavigationOperatorName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:707:2: ( ( ruleEssentialOCLUnaryOperatorName ) )
            // InternalQVTbase.g:708:1: ( ruleEssentialOCLUnaryOperatorName )
            {
            // InternalQVTbase.g:708:1: ( ruleEssentialOCLUnaryOperatorName )
            // InternalQVTbase.g:709:1: ruleEssentialOCLUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnaryOperatorNameAccess().getEssentialOCLUnaryOperatorNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnaryOperatorName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:735:2: ( ( ruleIdentifier ) )
            // InternalQVTbase.g:736:1: ( ruleIdentifier )
            {
            // InternalQVTbase.g:736:1: ( ruleIdentifier )
            // InternalQVTbase.g:737:1: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnrestrictedNameAccess().getIdentifierParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleIdentifier();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:763:2: ( ( ruleEssentialOCLUnrestrictedName ) )
            // InternalQVTbase.g:764:1: ( ruleEssentialOCLUnrestrictedName )
            {
            // InternalQVTbase.g:764:1: ( ruleEssentialOCLUnrestrictedName )
            // InternalQVTbase.g:765:1: ruleEssentialOCLUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnrestrictedNameAccess().getEssentialOCLUnrestrictedNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnrestrictedName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:791:2: ( ( ( rule__EssentialOCLUnreservedName__Alternatives ) ) )
            // InternalQVTbase.g:792:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            {
            // InternalQVTbase.g:792:1: ( ( rule__EssentialOCLUnreservedName__Alternatives ) )
            // InternalQVTbase.g:793:1: ( rule__EssentialOCLUnreservedName__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEssentialOCLUnreservedNameAccess().getAlternatives());
            }
            // InternalQVTbase.g:794:1: ( rule__EssentialOCLUnreservedName__Alternatives )
            // InternalQVTbase.g:794:2: rule__EssentialOCLUnreservedName__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EssentialOCLUnreservedName__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:819:2: ( ( ruleEssentialOCLUnreservedName ) )
            // InternalQVTbase.g:820:1: ( ruleEssentialOCLUnreservedName )
            {
            // InternalQVTbase.g:820:1: ( ruleEssentialOCLUnreservedName )
            // InternalQVTbase.g:821:1: ruleEssentialOCLUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnreservedNameAccess().getEssentialOCLUnreservedNameParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEssentialOCLUnreservedName();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:849:2: ( ( ( rule__URIFirstPathElementCS__Alternatives ) ) )
            // InternalQVTbase.g:850:1: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            {
            // InternalQVTbase.g:850:1: ( ( rule__URIFirstPathElementCS__Alternatives ) )
            // InternalQVTbase.g:851:1: ( rule__URIFirstPathElementCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:852:1: ( rule__URIFirstPathElementCS__Alternatives )
            // InternalQVTbase.g:852:2: rule__URIFirstPathElementCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:879:2: ( ( ( rule__PrimitiveTypeIdentifier__Alternatives ) ) )
            // InternalQVTbase.g:880:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            {
            // InternalQVTbase.g:880:1: ( ( rule__PrimitiveTypeIdentifier__Alternatives ) )
            // InternalQVTbase.g:881:1: ( rule__PrimitiveTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeIdentifierAccess().getAlternatives());
            }
            // InternalQVTbase.g:882:1: ( rule__PrimitiveTypeIdentifier__Alternatives )
            // InternalQVTbase.g:882:2: rule__PrimitiveTypeIdentifier__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveTypeIdentifier__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:907:2: ( ( ( rule__PrimitiveTypeCS__NameAssignment ) ) )
            // InternalQVTbase.g:908:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            {
            // InternalQVTbase.g:908:1: ( ( rule__PrimitiveTypeCS__NameAssignment ) )
            // InternalQVTbase.g:909:1: ( rule__PrimitiveTypeCS__NameAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNameAssignment());
            }
            // InternalQVTbase.g:910:1: ( rule__PrimitiveTypeCS__NameAssignment )
            // InternalQVTbase.g:910:2: rule__PrimitiveTypeCS__NameAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveTypeCS__NameAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:935:2: ( ( ( rule__CollectionTypeIdentifier__Alternatives ) ) )
            // InternalQVTbase.g:936:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            {
            // InternalQVTbase.g:936:1: ( ( rule__CollectionTypeIdentifier__Alternatives ) )
            // InternalQVTbase.g:937:1: ( rule__CollectionTypeIdentifier__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeIdentifierAccess().getAlternatives());
            }
            // InternalQVTbase.g:938:1: ( rule__CollectionTypeIdentifier__Alternatives )
            // InternalQVTbase.g:938:2: rule__CollectionTypeIdentifier__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeIdentifier__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:963:2: ( ( ( rule__CollectionTypeCS__Group__0 ) ) )
            // InternalQVTbase.g:964:1: ( ( rule__CollectionTypeCS__Group__0 ) )
            {
            // InternalQVTbase.g:964:1: ( ( rule__CollectionTypeCS__Group__0 ) )
            // InternalQVTbase.g:965:1: ( rule__CollectionTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup());
            }
            // InternalQVTbase.g:966:1: ( rule__CollectionTypeCS__Group__0 )
            // InternalQVTbase.g:966:2: rule__CollectionTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:991:2: ( ( ( rule__MapTypeCS__Group__0 ) ) )
            // InternalQVTbase.g:992:1: ( ( rule__MapTypeCS__Group__0 ) )
            {
            // InternalQVTbase.g:992:1: ( ( rule__MapTypeCS__Group__0 ) )
            // InternalQVTbase.g:993:1: ( rule__MapTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup());
            }
            // InternalQVTbase.g:994:1: ( rule__MapTypeCS__Group__0 )
            // InternalQVTbase.g:994:2: rule__MapTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1019:2: ( ( ( rule__TupleTypeCS__Group__0 ) ) )
            // InternalQVTbase.g:1020:1: ( ( rule__TupleTypeCS__Group__0 ) )
            {
            // InternalQVTbase.g:1020:1: ( ( rule__TupleTypeCS__Group__0 ) )
            // InternalQVTbase.g:1021:1: ( rule__TupleTypeCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup());
            }
            // InternalQVTbase.g:1022:1: ( rule__TupleTypeCS__Group__0 )
            // InternalQVTbase.g:1022:2: rule__TupleTypeCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1047:2: ( ( ( rule__TuplePartCS__Group__0 ) ) )
            // InternalQVTbase.g:1048:1: ( ( rule__TuplePartCS__Group__0 ) )
            {
            // InternalQVTbase.g:1048:1: ( ( rule__TuplePartCS__Group__0 ) )
            // InternalQVTbase.g:1049:1: ( rule__TuplePartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getGroup());
            }
            // InternalQVTbase.g:1050:1: ( rule__TuplePartCS__Group__0 )
            // InternalQVTbase.g:1050:2: rule__TuplePartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1075:2: ( ( ( rule__CollectionLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1076:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1076:1: ( ( rule__CollectionLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1077:1: ( rule__CollectionLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1078:1: ( rule__CollectionLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1078:2: rule__CollectionLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1103:2: ( ( ( rule__CollectionLiteralPartCS__Alternatives ) ) )
            // InternalQVTbase.g:1104:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            {
            // InternalQVTbase.g:1104:1: ( ( rule__CollectionLiteralPartCS__Alternatives ) )
            // InternalQVTbase.g:1105:1: ( rule__CollectionLiteralPartCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1106:1: ( rule__CollectionLiteralPartCS__Alternatives )
            // InternalQVTbase.g:1106:2: rule__CollectionLiteralPartCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1131:2: ( ( ( rule__CollectionPatternCS__Group__0 ) ) )
            // InternalQVTbase.g:1132:1: ( ( rule__CollectionPatternCS__Group__0 ) )
            {
            // InternalQVTbase.g:1132:1: ( ( rule__CollectionPatternCS__Group__0 ) )
            // InternalQVTbase.g:1133:1: ( rule__CollectionPatternCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup());
            }
            // InternalQVTbase.g:1134:1: ( rule__CollectionPatternCS__Group__0 )
            // InternalQVTbase.g:1134:2: rule__CollectionPatternCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1159:2: ( ( ( rule__ShadowPartCS__Alternatives ) ) )
            // InternalQVTbase.g:1160:1: ( ( rule__ShadowPartCS__Alternatives ) )
            {
            // InternalQVTbase.g:1160:1: ( ( rule__ShadowPartCS__Alternatives ) )
            // InternalQVTbase.g:1161:1: ( rule__ShadowPartCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1162:1: ( rule__ShadowPartCS__Alternatives )
            // InternalQVTbase.g:1162:2: rule__ShadowPartCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1187:2: ( ( ( rule__PatternExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1188:1: ( ( rule__PatternExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1188:1: ( ( rule__PatternExpCS__Group__0 ) )
            // InternalQVTbase.g:1189:1: ( rule__PatternExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1190:1: ( rule__PatternExpCS__Group__0 )
            // InternalQVTbase.g:1190:2: rule__PatternExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1215:2: ( ( ( rule__LambdaLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1216:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1216:1: ( ( rule__LambdaLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1217:1: ( rule__LambdaLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1218:1: ( rule__LambdaLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1218:2: rule__LambdaLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1243:2: ( ( ( rule__MapLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1244:1: ( ( rule__MapLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1244:1: ( ( rule__MapLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1245:1: ( rule__MapLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1246:1: ( rule__MapLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1246:2: rule__MapLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1271:2: ( ( ( rule__MapLiteralPartCS__Group__0 ) ) )
            // InternalQVTbase.g:1272:1: ( ( rule__MapLiteralPartCS__Group__0 ) )
            {
            // InternalQVTbase.g:1272:1: ( ( rule__MapLiteralPartCS__Group__0 ) )
            // InternalQVTbase.g:1273:1: ( rule__MapLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getGroup());
            }
            // InternalQVTbase.g:1274:1: ( rule__MapLiteralPartCS__Group__0 )
            // InternalQVTbase.g:1274:2: rule__MapLiteralPartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1299:2: ( ( ( rule__PrimitiveLiteralExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1300:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1300:1: ( ( rule__PrimitiveLiteralExpCS__Alternatives ) )
            // InternalQVTbase.g:1301:1: ( rule__PrimitiveLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveLiteralExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1302:1: ( rule__PrimitiveLiteralExpCS__Alternatives )
            // InternalQVTbase.g:1302:2: rule__PrimitiveLiteralExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimitiveLiteralExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1327:2: ( ( ( rule__TupleLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1328:1: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1328:1: ( ( rule__TupleLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1329:1: ( rule__TupleLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1330:1: ( rule__TupleLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1330:2: rule__TupleLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1355:2: ( ( ( rule__TupleLiteralPartCS__Group__0 ) ) )
            // InternalQVTbase.g:1356:1: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            {
            // InternalQVTbase.g:1356:1: ( ( rule__TupleLiteralPartCS__Group__0 ) )
            // InternalQVTbase.g:1357:1: ( rule__TupleLiteralPartCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup());
            }
            // InternalQVTbase.g:1358:1: ( rule__TupleLiteralPartCS__Group__0 )
            // InternalQVTbase.g:1358:2: rule__TupleLiteralPartCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1383:2: ( ( ( rule__NumberLiteralExpCS__SymbolAssignment ) ) )
            // InternalQVTbase.g:1384:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            {
            // InternalQVTbase.g:1384:1: ( ( rule__NumberLiteralExpCS__SymbolAssignment ) )
            // InternalQVTbase.g:1385:1: ( rule__NumberLiteralExpCS__SymbolAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolAssignment());
            }
            // InternalQVTbase.g:1386:1: ( rule__NumberLiteralExpCS__SymbolAssignment )
            // InternalQVTbase.g:1386:2: rule__NumberLiteralExpCS__SymbolAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NumberLiteralExpCS__SymbolAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1411:2: ( ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) ) )
            // InternalQVTbase.g:1412:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            {
            // InternalQVTbase.g:1412:1: ( ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* ) )
            // InternalQVTbase.g:1413:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) ) ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            {
            // InternalQVTbase.g:1413:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment ) )
            // InternalQVTbase.g:1414:1: ( rule__StringLiteralExpCS__SegmentsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }
            // InternalQVTbase.g:1415:1: ( rule__StringLiteralExpCS__SegmentsAssignment )
            // InternalQVTbase.g:1415:2: rule__StringLiteralExpCS__SegmentsAssignment
            {
            pushFollow(FollowSets000.FOLLOW_3);
            rule__StringLiteralExpCS__SegmentsAssignment();

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

            }

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

            }

            // InternalQVTbase.g:1418:1: ( ( rule__StringLiteralExpCS__SegmentsAssignment )* )
            // InternalQVTbase.g:1419:1: ( rule__StringLiteralExpCS__SegmentsAssignment )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsAssignment());
            }
            // InternalQVTbase.g:1420:1: ( rule__StringLiteralExpCS__SegmentsAssignment )*
            loop1:
            do {
                int alt1=2;
                int LA1_0 = input.LA(1);

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


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

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

            	    }
            	    break;

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

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

            }


            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1446:2: ( ( ( rule__BooleanLiteralExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1447:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1447:1: ( ( rule__BooleanLiteralExpCS__Alternatives ) )
            // InternalQVTbase.g:1448:1: ( rule__BooleanLiteralExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1449:1: ( rule__BooleanLiteralExpCS__Alternatives )
            // InternalQVTbase.g:1449:2: rule__BooleanLiteralExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__BooleanLiteralExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1474:2: ( ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1475:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1475:1: ( ( rule__UnlimitedNaturalLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1476:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1477:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1477:2: rule__UnlimitedNaturalLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1502:2: ( ( ( rule__InvalidLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1503:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1503:1: ( ( rule__InvalidLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1504:1: ( rule__InvalidLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1505:1: ( rule__InvalidLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1505:2: rule__InvalidLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1530:2: ( ( ( rule__NullLiteralExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1531:1: ( ( rule__NullLiteralExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1531:1: ( ( rule__NullLiteralExpCS__Group__0 ) )
            // InternalQVTbase.g:1532:1: ( rule__NullLiteralExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1533:1: ( rule__NullLiteralExpCS__Group__0 )
            // InternalQVTbase.g:1533:2: rule__NullLiteralExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1558:2: ( ( ( rule__TypeLiteralCS__Alternatives ) ) )
            // InternalQVTbase.g:1559:1: ( ( rule__TypeLiteralCS__Alternatives ) )
            {
            // InternalQVTbase.g:1559:1: ( ( rule__TypeLiteralCS__Alternatives ) )
            // InternalQVTbase.g:1560:1: ( rule__TypeLiteralCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1561:1: ( rule__TypeLiteralCS__Alternatives )
            // InternalQVTbase.g:1561:2: rule__TypeLiteralCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1586:2: ( ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) ) )
            // InternalQVTbase.g:1587:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            {
            // InternalQVTbase.g:1587:1: ( ( rule__TypeLiteralWithMultiplicityCS__Group__0 ) )
            // InternalQVTbase.g:1588:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getGroup());
            }
            // InternalQVTbase.g:1589:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0 )
            // InternalQVTbase.g:1589:2: rule__TypeLiteralWithMultiplicityCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1614:2: ( ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) ) )
            // InternalQVTbase.g:1615:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            {
            // InternalQVTbase.g:1615:1: ( ( rule__TypeLiteralExpCS__OwnedTypeAssignment ) )
            // InternalQVTbase.g:1616:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeAssignment());
            }
            // InternalQVTbase.g:1617:1: ( rule__TypeLiteralExpCS__OwnedTypeAssignment )
            // InternalQVTbase.g:1617:2: rule__TypeLiteralExpCS__OwnedTypeAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralExpCS__OwnedTypeAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1642:2: ( ( ( rule__TypeNameExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1643:1: ( ( rule__TypeNameExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1643:1: ( ( rule__TypeNameExpCS__Group__0 ) )
            // InternalQVTbase.g:1644:1: ( rule__TypeNameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1645:1: ( rule__TypeNameExpCS__Group__0 )
            // InternalQVTbase.g:1645:2: rule__TypeNameExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1670:2: ( ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) ) )
            // InternalQVTbase.g:1671:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) )
            {
            // InternalQVTbase.g:1671:1: ( ( rule__TypeExpWithoutMultiplicityCS__Alternatives ) )
            // InternalQVTbase.g:1672:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1673:1: ( rule__TypeExpWithoutMultiplicityCS__Alternatives )
            // InternalQVTbase.g:1673:2: rule__TypeExpWithoutMultiplicityCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpWithoutMultiplicityCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1698:2: ( ( ( rule__TypeExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1699:1: ( ( rule__TypeExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1699:1: ( ( rule__TypeExpCS__Group__0 ) )
            // InternalQVTbase.g:1700:1: ( rule__TypeExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1701:1: ( rule__TypeExpCS__Group__0 )
            // InternalQVTbase.g:1701:2: rule__TypeExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1726:2: ( ( ( rule__ExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1727:1: ( ( rule__ExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1727:1: ( ( rule__ExpCS__Alternatives ) )
            // InternalQVTbase.g:1728:1: ( rule__ExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1729:1: ( rule__ExpCS__Alternatives )
            // InternalQVTbase.g:1729:2: rule__ExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1754:2: ( ( ( rule__PrefixedLetExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1755:1: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1755:1: ( ( rule__PrefixedLetExpCS__Alternatives ) )
            // InternalQVTbase.g:1756:1: ( rule__PrefixedLetExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1757:1: ( rule__PrefixedLetExpCS__Alternatives )
            // InternalQVTbase.g:1757:2: rule__PrefixedLetExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1782:2: ( ( ( rule__PrefixedPrimaryExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1783:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1783:1: ( ( rule__PrefixedPrimaryExpCS__Alternatives ) )
            // InternalQVTbase.g:1784:1: ( rule__PrefixedPrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1785:1: ( rule__PrefixedPrimaryExpCS__Alternatives )
            // InternalQVTbase.g:1785:2: rule__PrefixedPrimaryExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1810:2: ( ( ( rule__PrimaryExpCS__Alternatives ) ) )
            // InternalQVTbase.g:1811:1: ( ( rule__PrimaryExpCS__Alternatives ) )
            {
            // InternalQVTbase.g:1811:1: ( ( rule__PrimaryExpCS__Alternatives ) )
            // InternalQVTbase.g:1812:1: ( rule__PrimaryExpCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimaryExpCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1813:1: ( rule__PrimaryExpCS__Alternatives )
            // InternalQVTbase.g:1813:2: rule__PrimaryExpCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrimaryExpCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1838:2: ( ( ( rule__NameExpCS__Group__0 ) ) )
            // InternalQVTbase.g:1839:1: ( ( rule__NameExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:1839:1: ( ( rule__NameExpCS__Group__0 ) )
            // InternalQVTbase.g:1840:1: ( rule__NameExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:1841:1: ( rule__NameExpCS__Group__0 )
            // InternalQVTbase.g:1841:2: rule__NameExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1866:2: ( ( ( rule__CurlyBracketedClauseCS__Group__0 ) ) )
            // InternalQVTbase.g:1867:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            {
            // InternalQVTbase.g:1867:1: ( ( rule__CurlyBracketedClauseCS__Group__0 ) )
            // InternalQVTbase.g:1868:1: ( rule__CurlyBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup());
            }
            // InternalQVTbase.g:1869:1: ( rule__CurlyBracketedClauseCS__Group__0 )
            // InternalQVTbase.g:1869:2: rule__CurlyBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1894:2: ( ( ( rule__RoundBracketedClauseCS__Group__0 ) ) )
            // InternalQVTbase.g:1895:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            {
            // InternalQVTbase.g:1895:1: ( ( rule__RoundBracketedClauseCS__Group__0 ) )
            // InternalQVTbase.g:1896:1: ( rule__RoundBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup());
            }
            // InternalQVTbase.g:1897:1: ( rule__RoundBracketedClauseCS__Group__0 )
            // InternalQVTbase.g:1897:2: rule__RoundBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1922:2: ( ( ( rule__SquareBracketedClauseCS__Group__0 ) ) )
            // InternalQVTbase.g:1923:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            {
            // InternalQVTbase.g:1923:1: ( ( rule__SquareBracketedClauseCS__Group__0 ) )
            // InternalQVTbase.g:1924:1: ( rule__SquareBracketedClauseCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup());
            }
            // InternalQVTbase.g:1925:1: ( rule__SquareBracketedClauseCS__Group__0 )
            // InternalQVTbase.g:1925:2: rule__SquareBracketedClauseCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1950:2: ( ( ( rule__NavigatingArgCS__Alternatives ) ) )
            // InternalQVTbase.g:1951:1: ( ( rule__NavigatingArgCS__Alternatives ) )
            {
            // InternalQVTbase.g:1951:1: ( ( rule__NavigatingArgCS__Alternatives ) )
            // InternalQVTbase.g:1952:1: ( rule__NavigatingArgCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:1953:1: ( rule__NavigatingArgCS__Alternatives )
            // InternalQVTbase.g:1953:2: rule__NavigatingArgCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:1978:2: ( ( ( rule__NavigatingBarArgCS__Group__0 ) ) )
            // InternalQVTbase.g:1979:1: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            {
            // InternalQVTbase.g:1979:1: ( ( rule__NavigatingBarArgCS__Group__0 ) )
            // InternalQVTbase.g:1980:1: ( rule__NavigatingBarArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup());
            }
            // InternalQVTbase.g:1981:1: ( rule__NavigatingBarArgCS__Group__0 )
            // InternalQVTbase.g:1981:2: rule__NavigatingBarArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2006:2: ( ( ( rule__NavigatingCommaArgCS__Group__0 ) ) )
            // InternalQVTbase.g:2007:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            {
            // InternalQVTbase.g:2007:1: ( ( rule__NavigatingCommaArgCS__Group__0 ) )
            // InternalQVTbase.g:2008:1: ( rule__NavigatingCommaArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup());
            }
            // InternalQVTbase.g:2009:1: ( rule__NavigatingCommaArgCS__Group__0 )
            // InternalQVTbase.g:2009:2: rule__NavigatingCommaArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2034:2: ( ( ( rule__NavigatingSemiArgCS__Group__0 ) ) )
            // InternalQVTbase.g:2035:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            {
            // InternalQVTbase.g:2035:1: ( ( rule__NavigatingSemiArgCS__Group__0 ) )
            // InternalQVTbase.g:2036:1: ( rule__NavigatingSemiArgCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup());
            }
            // InternalQVTbase.g:2037:1: ( rule__NavigatingSemiArgCS__Group__0 )
            // InternalQVTbase.g:2037:2: rule__NavigatingSemiArgCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2062:2: ( ( ruleExpCS ) )
            // InternalQVTbase.g:2063:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:2063:1: ( ruleExpCS )
            // InternalQVTbase.g:2064:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgExpCSAccess().getExpCSParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2090:2: ( ( ( rule__CoIteratorVariableCS__Group__0 ) ) )
            // InternalQVTbase.g:2091:1: ( ( rule__CoIteratorVariableCS__Group__0 ) )
            {
            // InternalQVTbase.g:2091:1: ( ( rule__CoIteratorVariableCS__Group__0 ) )
            // InternalQVTbase.g:2092:1: ( rule__CoIteratorVariableCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getGroup());
            }
            // InternalQVTbase.g:2093:1: ( rule__CoIteratorVariableCS__Group__0 )
            // InternalQVTbase.g:2093:2: rule__CoIteratorVariableCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2118:2: ( ( ( rule__IfExpCS__Group__0 ) ) )
            // InternalQVTbase.g:2119:1: ( ( rule__IfExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:2119:1: ( ( rule__IfExpCS__Group__0 ) )
            // InternalQVTbase.g:2120:1: ( rule__IfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:2121:1: ( rule__IfExpCS__Group__0 )
            // InternalQVTbase.g:2121:2: rule__IfExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2146:2: ( ( ( rule__ElseIfThenExpCS__Group__0 ) ) )
            // InternalQVTbase.g:2147:1: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:2147:1: ( ( rule__ElseIfThenExpCS__Group__0 ) )
            // InternalQVTbase.g:2148:1: ( rule__ElseIfThenExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:2149:1: ( rule__ElseIfThenExpCS__Group__0 )
            // InternalQVTbase.g:2149:2: rule__ElseIfThenExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2174:2: ( ( ( rule__LetExpCS__Group__0 ) ) )
            // InternalQVTbase.g:2175:1: ( ( rule__LetExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:2175:1: ( ( rule__LetExpCS__Group__0 ) )
            // InternalQVTbase.g:2176:1: ( rule__LetExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:2177:1: ( rule__LetExpCS__Group__0 )
            // InternalQVTbase.g:2177:2: rule__LetExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2202:2: ( ( ( rule__LetVariableCS__Group__0 ) ) )
            // InternalQVTbase.g:2203:1: ( ( rule__LetVariableCS__Group__0 ) )
            {
            // InternalQVTbase.g:2203:1: ( ( rule__LetVariableCS__Group__0 ) )
            // InternalQVTbase.g:2204:1: ( rule__LetVariableCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup());
            }
            // InternalQVTbase.g:2205:1: ( rule__LetVariableCS__Group__0 )
            // InternalQVTbase.g:2205:2: rule__LetVariableCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2230:2: ( ( ( rule__NestedExpCS__Group__0 ) ) )
            // InternalQVTbase.g:2231:1: ( ( rule__NestedExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:2231:1: ( ( rule__NestedExpCS__Group__0 ) )
            // InternalQVTbase.g:2232:1: ( rule__NestedExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:2233:1: ( rule__NestedExpCS__Group__0 )
            // InternalQVTbase.g:2233:2: rule__NestedExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2258:2: ( ( ( rule__SelfExpCS__Group__0 ) ) )
            // InternalQVTbase.g:2259:1: ( ( rule__SelfExpCS__Group__0 ) )
            {
            // InternalQVTbase.g:2259:1: ( ( rule__SelfExpCS__Group__0 ) )
            // InternalQVTbase.g:2260:1: ( rule__SelfExpCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getGroup());
            }
            // InternalQVTbase.g:2261:1: ( rule__SelfExpCS__Group__0 )
            // InternalQVTbase.g:2261:2: rule__SelfExpCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2286:2: ( ( ( rule__MultiplicityBoundsCS__Group__0 ) ) )
            // InternalQVTbase.g:2287:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            {
            // InternalQVTbase.g:2287:1: ( ( rule__MultiplicityBoundsCS__Group__0 ) )
            // InternalQVTbase.g:2288:1: ( rule__MultiplicityBoundsCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup());
            }
            // InternalQVTbase.g:2289:1: ( rule__MultiplicityBoundsCS__Group__0 )
            // InternalQVTbase.g:2289:2: rule__MultiplicityBoundsCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2314:2: ( ( ( rule__MultiplicityCS__Group__0 ) ) )
            // InternalQVTbase.g:2315:1: ( ( rule__MultiplicityCS__Group__0 ) )
            {
            // InternalQVTbase.g:2315:1: ( ( rule__MultiplicityCS__Group__0 ) )
            // InternalQVTbase.g:2316:1: ( rule__MultiplicityCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getGroup());
            }
            // InternalQVTbase.g:2317:1: ( rule__MultiplicityCS__Group__0 )
            // InternalQVTbase.g:2317:2: rule__MultiplicityCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2342:2: ( ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) ) )
            // InternalQVTbase.g:2343:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            {
            // InternalQVTbase.g:2343:1: ( ( rule__MultiplicityStringCS__StringBoundsAssignment ) )
            // InternalQVTbase.g:2344:1: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAssignment());
            }
            // InternalQVTbase.g:2345:1: ( rule__MultiplicityStringCS__StringBoundsAssignment )
            // InternalQVTbase.g:2345:2: rule__MultiplicityStringCS__StringBoundsAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityStringCS__StringBoundsAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2370:2: ( ( ( rule__PathNameCS__Group__0 ) ) )
            // InternalQVTbase.g:2371:1: ( ( rule__PathNameCS__Group__0 ) )
            {
            // InternalQVTbase.g:2371:1: ( ( rule__PathNameCS__Group__0 ) )
            // InternalQVTbase.g:2372:1: ( rule__PathNameCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup());
            }
            // InternalQVTbase.g:2373:1: ( rule__PathNameCS__Group__0 )
            // InternalQVTbase.g:2373:2: rule__PathNameCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2398:2: ( ( ( rule__FirstPathElementCS__ReferredElementAssignment ) ) )
            // InternalQVTbase.g:2399:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            {
            // InternalQVTbase.g:2399:1: ( ( rule__FirstPathElementCS__ReferredElementAssignment ) )
            // InternalQVTbase.g:2400:1: ( rule__FirstPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementAssignment());
            }
            // InternalQVTbase.g:2401:1: ( rule__FirstPathElementCS__ReferredElementAssignment )
            // InternalQVTbase.g:2401:2: rule__FirstPathElementCS__ReferredElementAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__FirstPathElementCS__ReferredElementAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2426:2: ( ( ( rule__NextPathElementCS__ReferredElementAssignment ) ) )
            // InternalQVTbase.g:2427:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            {
            // InternalQVTbase.g:2427:1: ( ( rule__NextPathElementCS__ReferredElementAssignment ) )
            // InternalQVTbase.g:2428:1: ( rule__NextPathElementCS__ReferredElementAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementAssignment());
            }
            // InternalQVTbase.g:2429:1: ( rule__NextPathElementCS__ReferredElementAssignment )
            // InternalQVTbase.g:2429:2: rule__NextPathElementCS__ReferredElementAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NextPathElementCS__ReferredElementAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2454:2: ( ( ( rule__TemplateBindingCS__Group__0 ) ) )
            // InternalQVTbase.g:2455:1: ( ( rule__TemplateBindingCS__Group__0 ) )
            {
            // InternalQVTbase.g:2455:1: ( ( rule__TemplateBindingCS__Group__0 ) )
            // InternalQVTbase.g:2456:1: ( rule__TemplateBindingCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup());
            }
            // InternalQVTbase.g:2457:1: ( rule__TemplateBindingCS__Group__0 )
            // InternalQVTbase.g:2457:2: rule__TemplateBindingCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2482:2: ( ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) ) )
            // InternalQVTbase.g:2483:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            {
            // InternalQVTbase.g:2483:1: ( ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment ) )
            // InternalQVTbase.g:2484:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterAssignment());
            }
            // InternalQVTbase.g:2485:1: ( rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment )
            // InternalQVTbase.g:2485:2: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleTemplateSignatureCS"
    // InternalQVTbase.g:2497:1: entryRuleTemplateSignatureCS : ruleTemplateSignatureCS EOF ;
    public final void entryRuleTemplateSignatureCS() throws RecognitionException {
        try {
            // InternalQVTbase.g:2498:1: ( ruleTemplateSignatureCS EOF )
            // InternalQVTbase.g:2499:1: ruleTemplateSignatureCS EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSRule());
            }
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTemplateSignatureCS();

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

            }

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


    // $ANTLR start "ruleTemplateSignatureCS"
    // InternalQVTbase.g:2506:1: ruleTemplateSignatureCS : ( ( rule__TemplateSignatureCS__Group__0 ) ) ;
    public final void ruleTemplateSignatureCS() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2510:2: ( ( ( rule__TemplateSignatureCS__Group__0 ) ) )
            // InternalQVTbase.g:2511:1: ( ( rule__TemplateSignatureCS__Group__0 ) )
            {
            // InternalQVTbase.g:2511:1: ( ( rule__TemplateSignatureCS__Group__0 ) )
            // InternalQVTbase.g:2512:1: ( rule__TemplateSignatureCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getGroup());
            }
            // InternalQVTbase.g:2513:1: ( rule__TemplateSignatureCS__Group__0 )
            // InternalQVTbase.g:2513:2: rule__TemplateSignatureCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2538:2: ( ( ( rule__TypeParameterCS__Group__0 ) ) )
            // InternalQVTbase.g:2539:1: ( ( rule__TypeParameterCS__Group__0 ) )
            {
            // InternalQVTbase.g:2539:1: ( ( rule__TypeParameterCS__Group__0 ) )
            // InternalQVTbase.g:2540:1: ( rule__TypeParameterCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup());
            }
            // InternalQVTbase.g:2541:1: ( rule__TypeParameterCS__Group__0 )
            // InternalQVTbase.g:2541:2: rule__TypeParameterCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2566:2: ( ( ( rule__TypeRefCS__Alternatives ) ) )
            // InternalQVTbase.g:2567:1: ( ( rule__TypeRefCS__Alternatives ) )
            {
            // InternalQVTbase.g:2567:1: ( ( rule__TypeRefCS__Alternatives ) )
            // InternalQVTbase.g:2568:1: ( rule__TypeRefCS__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeRefCSAccess().getAlternatives());
            }
            // InternalQVTbase.g:2569:1: ( rule__TypeRefCS__Alternatives )
            // InternalQVTbase.g:2569:2: rule__TypeRefCS__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeRefCS__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2594:2: ( ( ( rule__TypedTypeRefCS__Group__0 ) ) )
            // InternalQVTbase.g:2595:1: ( ( rule__TypedTypeRefCS__Group__0 ) )
            {
            // InternalQVTbase.g:2595:1: ( ( rule__TypedTypeRefCS__Group__0 ) )
            // InternalQVTbase.g:2596:1: ( rule__TypedTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup());
            }
            // InternalQVTbase.g:2597:1: ( rule__TypedTypeRefCS__Group__0 )
            // InternalQVTbase.g:2597:2: rule__TypedTypeRefCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2622:2: ( ( ( rule__WildcardTypeRefCS__Group__0 ) ) )
            // InternalQVTbase.g:2623:1: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            {
            // InternalQVTbase.g:2623:1: ( ( rule__WildcardTypeRefCS__Group__0 ) )
            // InternalQVTbase.g:2624:1: ( rule__WildcardTypeRefCS__Group__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup());
            }
            // InternalQVTbase.g:2625:1: ( rule__WildcardTypeRefCS__Group__0 )
            // InternalQVTbase.g:2625:2: rule__WildcardTypeRefCS__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__0();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2650:2: ( ( ( rule__ID__Alternatives ) ) )
            // InternalQVTbase.g:2651:1: ( ( rule__ID__Alternatives ) )
            {
            // InternalQVTbase.g:2651:1: ( ( rule__ID__Alternatives ) )
            // InternalQVTbase.g:2652:1: ( rule__ID__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIDAccess().getAlternatives());
            }
            // InternalQVTbase.g:2653:1: ( rule__ID__Alternatives )
            // InternalQVTbase.g:2653:2: rule__ID__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ID__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2678:2: ( ( ruleID ) )
            // InternalQVTbase.g:2679:1: ( ruleID )
            {
            // InternalQVTbase.g:2679:1: ( ruleID )
            // InternalQVTbase.g:2680:1: ruleID
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdentifierAccess().getIDParserRuleCall());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleID();

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2706:2: ( ( RULE_INT ) )
            // InternalQVTbase.g:2707:1: ( RULE_INT )
            {
            // InternalQVTbase.g:2707:1: ( RULE_INT )
            // InternalQVTbase.g:2708:1: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLOWERAccess().getINTTerminalRuleCall());
            }
            match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLOWERAccess().getINTTerminalRuleCall());
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2734:2: ( ( RULE_INT ) )
            // InternalQVTbase.g:2735:1: ( RULE_INT )
            {
            // InternalQVTbase.g:2735:1: ( RULE_INT )
            // InternalQVTbase.g:2736:1: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall());
            }
            match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNUMBER_LITERALAccess().getINTTerminalRuleCall());
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2762:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:2763:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:2763:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:2764:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2790:2: ( ( ( rule__UPPER__Alternatives ) ) )
            // InternalQVTbase.g:2791:1: ( ( rule__UPPER__Alternatives ) )
            {
            // InternalQVTbase.g:2791:1: ( ( rule__UPPER__Alternatives ) )
            // InternalQVTbase.g:2792:1: ( rule__UPPER__Alternatives )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUPPERAccess().getAlternatives());
            }
            // InternalQVTbase.g:2793:1: ( rule__UPPER__Alternatives )
            // InternalQVTbase.g:2793:2: rule__UPPER__Alternatives
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UPPER__Alternatives();

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

            }

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

            }


            }

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

            	restoreStackSize(stackSize);

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


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

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

            }

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


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

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2818:2: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:2819:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:2819:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:2820:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIAccess().getSINGLE_QUOTED_STRINGTerminalRuleCall());
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AttributeCS__Alternatives_0"
    // InternalQVTbase.g:2833:1: rule__AttributeCS__Alternatives_0 : ( ( ( rule__AttributeCS__Group_0_0__0 ) ) | ( ( rule__AttributeCS__Group_0_1__0 ) ) );
    public final void rule__AttributeCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2837:1: ( ( ( rule__AttributeCS__Group_0_0__0 ) ) | ( ( rule__AttributeCS__Group_0_1__0 ) ) )
            int alt2=2;
            int LA2_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt2) {
                case 1 :
                    // InternalQVTbase.g:2838:1: ( ( rule__AttributeCS__Group_0_0__0 ) )
                    {
                    // InternalQVTbase.g:2838:1: ( ( rule__AttributeCS__Group_0_0__0 ) )
                    // InternalQVTbase.g:2839:1: ( rule__AttributeCS__Group_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getGroup_0_0());
                    }
                    // InternalQVTbase.g:2840:1: ( rule__AttributeCS__Group_0_0__0 )
                    // InternalQVTbase.g:2840:2: rule__AttributeCS__Group_0_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_0_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getGroup_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:2844:6: ( ( rule__AttributeCS__Group_0_1__0 ) )
                    {
                    // InternalQVTbase.g:2844:6: ( ( rule__AttributeCS__Group_0_1__0 ) )
                    // InternalQVTbase.g:2845:1: ( rule__AttributeCS__Group_0_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getGroup_0_1());
                    }
                    // InternalQVTbase.g:2846:1: ( rule__AttributeCS__Group_0_1__0 )
                    // InternalQVTbase.g:2846:2: rule__AttributeCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_0_1__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getGroup_0_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AttributeCS__Alternatives_5_1_0"
    // InternalQVTbase.g:2855:1: rule__AttributeCS__Alternatives_5_1_0 : ( ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 ) ) );
    public final void rule__AttributeCS__Alternatives_5_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2859:1: ( ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 ) ) | ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 ) ) )
            int alt3=16;
            switch ( input.LA(1) ) {
            case 101:
                {
                alt3=1;
                }
                break;
            case 102:
                {
                alt3=2;
                }
                break;
            case 103:
                {
                alt3=3;
                }
                break;
            case 104:
                {
                alt3=4;
                }
                break;
            case 105:
                {
                alt3=5;
                }
                break;
            case 106:
                {
                alt3=6;
                }
                break;
            case 107:
                {
                alt3=7;
                }
                break;
            case 108:
                {
                alt3=8;
                }
                break;
            case 109:
                {
                alt3=9;
                }
                break;
            case 110:
                {
                alt3=10;
                }
                break;
            case 111:
                {
                alt3=11;
                }
                break;
            case 112:
                {
                alt3=12;
                }
                break;
            case 113:
                {
                alt3=13;
                }
                break;
            case 114:
                {
                alt3=14;
                }
                break;
            case 115:
                {
                alt3=15;
                }
                break;
            case 116:
                {
                alt3=16;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 3, 0, input);

                throw nvae;
            }

            switch (alt3) {
                case 1 :
                    // InternalQVTbase.g:2860:1: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 ) )
                    {
                    // InternalQVTbase.g:2860:1: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 ) )
                    // InternalQVTbase.g:2861:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_0());
                    }
                    // InternalQVTbase.g:2862:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_0 )
                    // InternalQVTbase.g:2862:2: rule__AttributeCS__QualifiersAssignment_5_1_0_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:2866:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 ) )
                    {
                    // InternalQVTbase.g:2866:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 ) )
                    // InternalQVTbase.g:2867:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_1());
                    }
                    // InternalQVTbase.g:2868:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_1 )
                    // InternalQVTbase.g:2868:2: rule__AttributeCS__QualifiersAssignment_5_1_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_1();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:2872:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 ) )
                    {
                    // InternalQVTbase.g:2872:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 ) )
                    // InternalQVTbase.g:2873:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_2());
                    }
                    // InternalQVTbase.g:2874:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_2 )
                    // InternalQVTbase.g:2874:2: rule__AttributeCS__QualifiersAssignment_5_1_0_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_2();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:2878:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 ) )
                    {
                    // InternalQVTbase.g:2878:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 ) )
                    // InternalQVTbase.g:2879:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_3());
                    }
                    // InternalQVTbase.g:2880:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_3 )
                    // InternalQVTbase.g:2880:2: rule__AttributeCS__QualifiersAssignment_5_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_3();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:2884:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 ) )
                    {
                    // InternalQVTbase.g:2884:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 ) )
                    // InternalQVTbase.g:2885:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_4());
                    }
                    // InternalQVTbase.g:2886:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_4 )
                    // InternalQVTbase.g:2886:2: rule__AttributeCS__QualifiersAssignment_5_1_0_4
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_4();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:2890:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 ) )
                    {
                    // InternalQVTbase.g:2890:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 ) )
                    // InternalQVTbase.g:2891:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_5());
                    }
                    // InternalQVTbase.g:2892:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_5 )
                    // InternalQVTbase.g:2892:2: rule__AttributeCS__QualifiersAssignment_5_1_0_5
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_5();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalQVTbase.g:2896:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 ) )
                    {
                    // InternalQVTbase.g:2896:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 ) )
                    // InternalQVTbase.g:2897:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_6());
                    }
                    // InternalQVTbase.g:2898:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_6 )
                    // InternalQVTbase.g:2898:2: rule__AttributeCS__QualifiersAssignment_5_1_0_6
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_6();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalQVTbase.g:2902:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 ) )
                    {
                    // InternalQVTbase.g:2902:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 ) )
                    // InternalQVTbase.g:2903:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_7());
                    }
                    // InternalQVTbase.g:2904:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_7 )
                    // InternalQVTbase.g:2904:2: rule__AttributeCS__QualifiersAssignment_5_1_0_7
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_7();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalQVTbase.g:2908:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 ) )
                    {
                    // InternalQVTbase.g:2908:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 ) )
                    // InternalQVTbase.g:2909:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_8());
                    }
                    // InternalQVTbase.g:2910:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_8 )
                    // InternalQVTbase.g:2910:2: rule__AttributeCS__QualifiersAssignment_5_1_0_8
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_8();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalQVTbase.g:2914:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 ) )
                    {
                    // InternalQVTbase.g:2914:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 ) )
                    // InternalQVTbase.g:2915:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_9());
                    }
                    // InternalQVTbase.g:2916:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_9 )
                    // InternalQVTbase.g:2916:2: rule__AttributeCS__QualifiersAssignment_5_1_0_9
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_9();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_9());
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalQVTbase.g:2920:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 ) )
                    {
                    // InternalQVTbase.g:2920:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 ) )
                    // InternalQVTbase.g:2921:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_10());
                    }
                    // InternalQVTbase.g:2922:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_10 )
                    // InternalQVTbase.g:2922:2: rule__AttributeCS__QualifiersAssignment_5_1_0_10
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_10();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_10());
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalQVTbase.g:2926:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 ) )
                    {
                    // InternalQVTbase.g:2926:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 ) )
                    // InternalQVTbase.g:2927:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_11());
                    }
                    // InternalQVTbase.g:2928:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_11 )
                    // InternalQVTbase.g:2928:2: rule__AttributeCS__QualifiersAssignment_5_1_0_11
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_11();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_11());
                    }

                    }


                    }
                    break;
                case 13 :
                    // InternalQVTbase.g:2932:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 ) )
                    {
                    // InternalQVTbase.g:2932:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 ) )
                    // InternalQVTbase.g:2933:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_12());
                    }
                    // InternalQVTbase.g:2934:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_12 )
                    // InternalQVTbase.g:2934:2: rule__AttributeCS__QualifiersAssignment_5_1_0_12
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_12();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_12());
                    }

                    }


                    }
                    break;
                case 14 :
                    // InternalQVTbase.g:2938:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 ) )
                    {
                    // InternalQVTbase.g:2938:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 ) )
                    // InternalQVTbase.g:2939:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_13());
                    }
                    // InternalQVTbase.g:2940:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_13 )
                    // InternalQVTbase.g:2940:2: rule__AttributeCS__QualifiersAssignment_5_1_0_13
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_13();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_13());
                    }

                    }


                    }
                    break;
                case 15 :
                    // InternalQVTbase.g:2944:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 ) )
                    {
                    // InternalQVTbase.g:2944:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 ) )
                    // InternalQVTbase.g:2945:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_14());
                    }
                    // InternalQVTbase.g:2946:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_14 )
                    // InternalQVTbase.g:2946:2: rule__AttributeCS__QualifiersAssignment_5_1_0_14
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_14();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_14());
                    }

                    }


                    }
                    break;
                case 16 :
                    // InternalQVTbase.g:2950:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 ) )
                    {
                    // InternalQVTbase.g:2950:6: ( ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 ) )
                    // InternalQVTbase.g:2951:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_15());
                    }
                    // InternalQVTbase.g:2952:1: ( rule__AttributeCS__QualifiersAssignment_5_1_0_15 )
                    // InternalQVTbase.g:2952:2: rule__AttributeCS__QualifiersAssignment_5_1_0_15
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_5_1_0_15();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_5_1_0_15());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AttributeCS__Alternatives_6"
    // InternalQVTbase.g:2961:1: rule__AttributeCS__Alternatives_6 : ( ( ( rule__AttributeCS__Group_6_0__0 ) ) | ( ';' ) );
    public final void rule__AttributeCS__Alternatives_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2965:1: ( ( ( rule__AttributeCS__Group_6_0__0 ) ) | ( ';' ) )
            int alt4=2;
            int LA4_0 = input.LA(1);

            if ( (LA4_0==62) ) {
                alt4=1;
            }
            else if ( (LA4_0==17) ) {
                alt4=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 4, 0, input);

                throw nvae;
            }
            switch (alt4) {
                case 1 :
                    // InternalQVTbase.g:2966:1: ( ( rule__AttributeCS__Group_6_0__0 ) )
                    {
                    // InternalQVTbase.g:2966:1: ( ( rule__AttributeCS__Group_6_0__0 ) )
                    // InternalQVTbase.g:2967:1: ( rule__AttributeCS__Group_6_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getGroup_6_0());
                    }
                    // InternalQVTbase.g:2968:1: ( rule__AttributeCS__Group_6_0__0 )
                    // InternalQVTbase.g:2968:2: rule__AttributeCS__Group_6_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_6_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getGroup_6_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:2972:6: ( ';' )
                    {
                    // InternalQVTbase.g:2972:6: ( ';' )
                    // InternalQVTbase.g:2973:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__AttributeCS__Alternatives_6_0_1"
    // InternalQVTbase.g:2985:1: rule__AttributeCS__Alternatives_6_0_1 : ( ( ( rule__AttributeCS__Group_6_0_1_0__0 ) ) | ( ( rule__AttributeCS__Group_6_0_1_1__0 ) ) );
    public final void rule__AttributeCS__Alternatives_6_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:2989:1: ( ( ( rule__AttributeCS__Group_6_0_1_0__0 ) ) | ( ( rule__AttributeCS__Group_6_0_1_1__0 ) ) )
            int alt5=2;
            int LA5_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt5) {
                case 1 :
                    // InternalQVTbase.g:2990:1: ( ( rule__AttributeCS__Group_6_0_1_0__0 ) )
                    {
                    // InternalQVTbase.g:2990:1: ( ( rule__AttributeCS__Group_6_0_1_0__0 ) )
                    // InternalQVTbase.g:2991:1: ( rule__AttributeCS__Group_6_0_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getGroup_6_0_1_0());
                    }
                    // InternalQVTbase.g:2992:1: ( rule__AttributeCS__Group_6_0_1_0__0 )
                    // InternalQVTbase.g:2992:2: rule__AttributeCS__Group_6_0_1_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_6_0_1_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getGroup_6_0_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:2996:6: ( ( rule__AttributeCS__Group_6_0_1_1__0 ) )
                    {
                    // InternalQVTbase.g:2996:6: ( ( rule__AttributeCS__Group_6_0_1_1__0 ) )
                    // InternalQVTbase.g:2997:1: ( rule__AttributeCS__Group_6_0_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getAttributeCSAccess().getGroup_6_0_1_1());
                    }
                    // InternalQVTbase.g:2998:1: ( rule__AttributeCS__Group_6_0_1_1__0 )
                    // InternalQVTbase.g:2998:2: rule__AttributeCS__Group_6_0_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_6_0_1_1__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getAttributeCSAccess().getGroup_6_0_1_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DataTypeCS__Alternatives_5_1"
    // InternalQVTbase.g:3008:1: rule__DataTypeCS__Alternatives_5_1 : ( ( ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 ) ) | ( '!serializable' ) );
    public final void rule__DataTypeCS__Alternatives_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3012:1: ( ( ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 ) ) | ( '!serializable' ) )
            int alt6=2;
            int LA6_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt6) {
                case 1 :
                    // InternalQVTbase.g:3013:1: ( ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 ) )
                    {
                    // InternalQVTbase.g:3013:1: ( ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 ) )
                    // InternalQVTbase.g:3014:1: ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDataTypeCSAccess().getIsSerializableAssignment_5_1_0());
                    }
                    // InternalQVTbase.g:3015:1: ( rule__DataTypeCS__IsSerializableAssignment_5_1_0 )
                    // InternalQVTbase.g:3015:2: rule__DataTypeCS__IsSerializableAssignment_5_1_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__IsSerializableAssignment_5_1_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDataTypeCSAccess().getIsSerializableAssignment_5_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3019:6: ( '!serializable' )
                    {
                    // InternalQVTbase.g:3019:6: ( '!serializable' )
                    // InternalQVTbase.g:3020:1: '!serializable'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDataTypeCSAccess().getSerializableKeyword_5_1_1());
                    }
                    match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDataTypeCSAccess().getSerializableKeyword_5_1_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__DataTypeCS__Alternatives_6"
    // InternalQVTbase.g:3032:1: rule__DataTypeCS__Alternatives_6 : ( ( ( rule__DataTypeCS__Group_6_0__0 ) ) | ( ';' ) );
    public final void rule__DataTypeCS__Alternatives_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3036:1: ( ( ( rule__DataTypeCS__Group_6_0__0 ) ) | ( ';' ) )
            int alt7=2;
            int LA7_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt7) {
                case 1 :
                    // InternalQVTbase.g:3037:1: ( ( rule__DataTypeCS__Group_6_0__0 ) )
                    {
                    // InternalQVTbase.g:3037:1: ( ( rule__DataTypeCS__Group_6_0__0 ) )
                    // InternalQVTbase.g:3038:1: ( rule__DataTypeCS__Group_6_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDataTypeCSAccess().getGroup_6_0());
                    }
                    // InternalQVTbase.g:3039:1: ( rule__DataTypeCS__Group_6_0__0 )
                    // InternalQVTbase.g:3039:2: rule__DataTypeCS__Group_6_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__Group_6_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDataTypeCSAccess().getGroup_6_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3043:6: ( ';' )
                    {
                    // InternalQVTbase.g:3043:6: ( ';' )
                    // InternalQVTbase.g:3044:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getDataTypeCSAccess().getSemicolonKeyword_6_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getDataTypeCSAccess().getSemicolonKeyword_6_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EnumerationCS__Alternatives_4_1"
    // InternalQVTbase.g:3056:1: rule__EnumerationCS__Alternatives_4_1 : ( ( ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 ) ) | ( '!serializable' ) );
    public final void rule__EnumerationCS__Alternatives_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3060:1: ( ( ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 ) ) | ( '!serializable' ) )
            int alt8=2;
            int LA8_0 = input.LA(1);

            if ( (LA8_0==118) ) {
                alt8=1;
            }
            else if ( (LA8_0==18) ) {
                alt8=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 8, 0, input);

                throw nvae;
            }
            switch (alt8) {
                case 1 :
                    // InternalQVTbase.g:3061:1: ( ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 ) )
                    {
                    // InternalQVTbase.g:3061:1: ( ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 ) )
                    // InternalQVTbase.g:3062:1: ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationCSAccess().getIsSerializableAssignment_4_1_0());
                    }
                    // InternalQVTbase.g:3063:1: ( rule__EnumerationCS__IsSerializableAssignment_4_1_0 )
                    // InternalQVTbase.g:3063:2: rule__EnumerationCS__IsSerializableAssignment_4_1_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__IsSerializableAssignment_4_1_0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationCSAccess().getIsSerializableAssignment_4_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3067:6: ( '!serializable' )
                    {
                    // InternalQVTbase.g:3067:6: ( '!serializable' )
                    // InternalQVTbase.g:3068:1: '!serializable'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationCSAccess().getSerializableKeyword_4_1_1());
                    }
                    match(input,18,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationCSAccess().getSerializableKeyword_4_1_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EnumerationCS__Alternatives_5"
    // InternalQVTbase.g:3080:1: rule__EnumerationCS__Alternatives_5 : ( ( ( rule__EnumerationCS__Group_5_0__0 ) ) | ( ';' ) );
    public final void rule__EnumerationCS__Alternatives_5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3084:1: ( ( ( rule__EnumerationCS__Group_5_0__0 ) ) | ( ';' ) )
            int alt9=2;
            int LA9_0 = input.LA(1);

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

                throw nvae;
            }
            switch (alt9) {
                case 1 :
                    // InternalQVTbase.g:3085:1: ( ( rule__EnumerationCS__Group_5_0__0 ) )
                    {
                    // InternalQVTbase.g:3085:1: ( ( rule__EnumerationCS__Group_5_0__0 ) )
                    // InternalQVTbase.g:3086:1: ( rule__EnumerationCS__Group_5_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationCSAccess().getGroup_5_0());
                    }
                    // InternalQVTbase.g:3087:1: ( rule__EnumerationCS__Group_5_0__0 )
                    // InternalQVTbase.g:3087:2: rule__EnumerationCS__Group_5_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__Group_5_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationCSAccess().getGroup_5_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3091:6: ( ';' )
                    {
                    // InternalQVTbase.g:3091:6: ( ';' )
                    // InternalQVTbase.g:3092:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationCSAccess().getSemicolonKeyword_5_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationCSAccess().getSemicolonKeyword_5_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EnumerationLiteralCS__Alternatives_0"
    // InternalQVTbase.g:3104:1: rule__EnumerationLiteralCS__Alternatives_0 : ( ( ( rule__EnumerationLiteralCS__Group_0_0__0 ) ) | ( ( rule__EnumerationLiteralCS__NameAssignment_0_1 ) ) );
    public final void rule__EnumerationLiteralCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3108:1: ( ( ( rule__EnumerationLiteralCS__Group_0_0__0 ) ) | ( ( rule__EnumerationLiteralCS__NameAssignment_0_1 ) ) )
            int alt10=2;
            int LA10_0 = input.LA(1);

            if ( (LA10_0==69) ) {
                alt10=1;
            }
            else if ( ((LA10_0>=RULE_SIMPLE_ID && LA10_0<=RULE_ESCAPED_ID)) ) {
                alt10=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 10, 0, input);

                throw nvae;
            }
            switch (alt10) {
                case 1 :
                    // InternalQVTbase.g:3109:1: ( ( rule__EnumerationLiteralCS__Group_0_0__0 ) )
                    {
                    // InternalQVTbase.g:3109:1: ( ( rule__EnumerationLiteralCS__Group_0_0__0 ) )
                    // InternalQVTbase.g:3110:1: ( rule__EnumerationLiteralCS__Group_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationLiteralCSAccess().getGroup_0_0());
                    }
                    // InternalQVTbase.g:3111:1: ( rule__EnumerationLiteralCS__Group_0_0__0 )
                    // InternalQVTbase.g:3111:2: rule__EnumerationLiteralCS__Group_0_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationLiteralCS__Group_0_0__0();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationLiteralCSAccess().getGroup_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3115:6: ( ( rule__EnumerationLiteralCS__NameAssignment_0_1 ) )
                    {
                    // InternalQVTbase.g:3115:6: ( ( rule__EnumerationLiteralCS__NameAssignment_0_1 ) )
                    // InternalQVTbase.g:3116:1: ( rule__EnumerationLiteralCS__NameAssignment_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationLiteralCSAccess().getNameAssignment_0_1());
                    }
                    // InternalQVTbase.g:3117:1: ( rule__EnumerationLiteralCS__NameAssignment_0_1 )
                    // InternalQVTbase.g:3117:2: rule__EnumerationLiteralCS__NameAssignment_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationLiteralCS__NameAssignment_0_1();

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

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationLiteralCSAccess().getNameAssignment_0_1());
                    }

                    }


                    }
                    break;

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "rule__EnumerationLiteralCS__Alternatives_2"
    // InternalQVTbase.g:3126:1: rule__EnumerationLiteralCS__Alternatives_2 : ( ( ( rule__EnumerationLiteralCS__Group_2_0__0 ) ) | ( ';' ) );
    public final void rule__EnumerationLiteralCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3130:1: ( ( ( rule__EnumerationLiteralCS__Group_2_0__0 ) ) | ( ';' ) )
            int alt11=2;
            int LA11_0 = input.LA(1);

            if ( (LA11_0==62) ) {
                alt11=1;
            }
            else if ( (LA11_0==17) ) {
                alt11=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 11, 0, input);

                throw nvae;
            }
            switch (alt11) {
                case 1 :
                    // InternalQVTbase.g:3131:1: ( ( rule__EnumerationLiteralCS__Group_2_0__0 ) )
                    {
                    // InternalQVTbase.g:3131:1: ( ( rule__EnumerationLiteralCS__Group_2_0__0 ) )
                    // InternalQVTbase.g:3132:1: ( rule__EnumerationLiteralCS__Group_2_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationLiteralCSAccess().getGroup_2_0());
                    }
                    // InternalQVTbase.g:3133:1: ( rule__EnumerationLiteralCS__Group_2_0__0 )
                    // InternalQVTbase.g:3133:2: rule__EnumerationLiteralCS__Group_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationLiteralCS__Group_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationLiteralCSAccess().getGroup_2_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3137:6: ( ';' )
                    {
                    // InternalQVTbase.g:3137:6: ( ';' )
                    // InternalQVTbase.g:3138:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEnumerationLiteralCSAccess().getSemicolonKeyword_2_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEnumerationLiteralCSAccess().getSemicolonKeyword_2_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Alternatives_2"


    // $ANTLR start "rule__OperationCS__Alternatives_0"
    // InternalQVTbase.g:3150:1: rule__OperationCS__Alternatives_0 : ( ( ( rule__OperationCS__Group_0_0__0 ) ) | ( ( rule__OperationCS__Group_0_1__0 ) ) );
    public final void rule__OperationCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3154:1: ( ( ( rule__OperationCS__Group_0_0__0 ) ) | ( ( rule__OperationCS__Group_0_1__0 ) ) )
            int alt12=2;
            int LA12_0 = input.LA(1);

            if ( (LA12_0==99) ) {
                alt12=1;
            }
            else if ( (LA12_0==100) ) {
                alt12=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 12, 0, input);

                throw nvae;
            }
            switch (alt12) {
                case 1 :
                    // InternalQVTbase.g:3155:1: ( ( rule__OperationCS__Group_0_0__0 ) )
                    {
                    // InternalQVTbase.g:3155:1: ( ( rule__OperationCS__Group_0_0__0 ) )
                    // InternalQVTbase.g:3156:1: ( rule__OperationCS__Group_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getGroup_0_0());
                    }
                    // InternalQVTbase.g:3157:1: ( rule__OperationCS__Group_0_0__0 )
                    // InternalQVTbase.g:3157:2: rule__OperationCS__Group_0_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_0_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getGroup_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3161:6: ( ( rule__OperationCS__Group_0_1__0 ) )
                    {
                    // InternalQVTbase.g:3161:6: ( ( rule__OperationCS__Group_0_1__0 ) )
                    // InternalQVTbase.g:3162:1: ( rule__OperationCS__Group_0_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getGroup_0_1());
                    }
                    // InternalQVTbase.g:3163:1: ( rule__OperationCS__Group_0_1__0 )
                    // InternalQVTbase.g:3163:2: rule__OperationCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getGroup_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Alternatives_0"


    // $ANTLR start "rule__OperationCS__Alternatives_9_1_0"
    // InternalQVTbase.g:3172:1: rule__OperationCS__Alternatives_9_1_0 : ( ( ( rule__OperationCS__QualifiersAssignment_9_1_0_0 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_1 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_2 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_3 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_4 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_5 ) ) );
    public final void rule__OperationCS__Alternatives_9_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3176:1: ( ( ( rule__OperationCS__QualifiersAssignment_9_1_0_0 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_1 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_2 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_3 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_4 ) ) | ( ( rule__OperationCS__QualifiersAssignment_9_1_0_5 ) ) )
            int alt13=6;
            switch ( input.LA(1) ) {
            case 101:
                {
                alt13=1;
                }
                break;
            case 102:
                {
                alt13=2;
                }
                break;
            case 105:
                {
                alt13=3;
                }
                break;
            case 106:
                {
                alt13=4;
                }
                break;
            case 111:
                {
                alt13=5;
                }
                break;
            case 112:
                {
                alt13=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 13, 0, input);

                throw nvae;
            }

            switch (alt13) {
                case 1 :
                    // InternalQVTbase.g:3177:1: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_0 ) )
                    {
                    // InternalQVTbase.g:3177:1: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_0 ) )
                    // InternalQVTbase.g:3178:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_0());
                    }
                    // InternalQVTbase.g:3179:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_0 )
                    // InternalQVTbase.g:3179:2: rule__OperationCS__QualifiersAssignment_9_1_0_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3183:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_1 ) )
                    {
                    // InternalQVTbase.g:3183:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_1 ) )
                    // InternalQVTbase.g:3184:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_1());
                    }
                    // InternalQVTbase.g:3185:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_1 )
                    // InternalQVTbase.g:3185:2: rule__OperationCS__QualifiersAssignment_9_1_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3189:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_2 ) )
                    {
                    // InternalQVTbase.g:3189:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_2 ) )
                    // InternalQVTbase.g:3190:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_2());
                    }
                    // InternalQVTbase.g:3191:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_2 )
                    // InternalQVTbase.g:3191:2: rule__OperationCS__QualifiersAssignment_9_1_0_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3195:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_3 ) )
                    {
                    // InternalQVTbase.g:3195:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_3 ) )
                    // InternalQVTbase.g:3196:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_3 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_3());
                    }
                    // InternalQVTbase.g:3197:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_3 )
                    // InternalQVTbase.g:3197:2: rule__OperationCS__QualifiersAssignment_9_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:3201:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_4 ) )
                    {
                    // InternalQVTbase.g:3201:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_4 ) )
                    // InternalQVTbase.g:3202:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_4 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_4());
                    }
                    // InternalQVTbase.g:3203:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_4 )
                    // InternalQVTbase.g:3203:2: rule__OperationCS__QualifiersAssignment_9_1_0_4
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_4();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:3207:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_5 ) )
                    {
                    // InternalQVTbase.g:3207:6: ( ( rule__OperationCS__QualifiersAssignment_9_1_0_5 ) )
                    // InternalQVTbase.g:3208:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_5 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_5());
                    }
                    // InternalQVTbase.g:3209:1: ( rule__OperationCS__QualifiersAssignment_9_1_0_5 )
                    // InternalQVTbase.g:3209:2: rule__OperationCS__QualifiersAssignment_9_1_0_5
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_9_1_0_5();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_9_1_0_5());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Alternatives_9_1_0"


    // $ANTLR start "rule__OperationCS__Alternatives_10"
    // InternalQVTbase.g:3218:1: rule__OperationCS__Alternatives_10 : ( ( ( rule__OperationCS__Group_10_0__0 ) ) | ( ';' ) );
    public final void rule__OperationCS__Alternatives_10() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3222:1: ( ( ( rule__OperationCS__Group_10_0__0 ) ) | ( ';' ) )
            int alt14=2;
            int LA14_0 = input.LA(1);

            if ( (LA14_0==62) ) {
                alt14=1;
            }
            else if ( (LA14_0==17) ) {
                alt14=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 14, 0, input);

                throw nvae;
            }
            switch (alt14) {
                case 1 :
                    // InternalQVTbase.g:3223:1: ( ( rule__OperationCS__Group_10_0__0 ) )
                    {
                    // InternalQVTbase.g:3223:1: ( ( rule__OperationCS__Group_10_0__0 ) )
                    // InternalQVTbase.g:3224:1: ( rule__OperationCS__Group_10_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getGroup_10_0());
                    }
                    // InternalQVTbase.g:3225:1: ( rule__OperationCS__Group_10_0__0 )
                    // InternalQVTbase.g:3225:2: rule__OperationCS__Group_10_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_10_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getGroup_10_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3229:6: ( ';' )
                    {
                    // InternalQVTbase.g:3229:6: ( ';' )
                    // InternalQVTbase.g:3230:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getOperationCSAccess().getSemicolonKeyword_10_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getOperationCSAccess().getSemicolonKeyword_10_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Alternatives_10"


    // $ANTLR start "rule__ParameterCS__Alternatives_2_1_0"
    // InternalQVTbase.g:3242:1: rule__ParameterCS__Alternatives_2_1_0 : ( ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 ) ) );
    public final void rule__ParameterCS__Alternatives_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3246:1: ( ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 ) ) | ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 ) ) )
            int alt15=4;
            switch ( input.LA(1) ) {
            case 105:
                {
                alt15=1;
                }
                break;
            case 106:
                {
                alt15=2;
                }
                break;
            case 111:
                {
                alt15=3;
                }
                break;
            case 112:
                {
                alt15=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 15, 0, input);

                throw nvae;
            }

            switch (alt15) {
                case 1 :
                    // InternalQVTbase.g:3247:1: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 ) )
                    {
                    // InternalQVTbase.g:3247:1: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 ) )
                    // InternalQVTbase.g:3248:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_0());
                    }
                    // InternalQVTbase.g:3249:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_0 )
                    // InternalQVTbase.g:3249:2: rule__ParameterCS__QualifiersAssignment_2_1_0_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__QualifiersAssignment_2_1_0_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3253:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 ) )
                    {
                    // InternalQVTbase.g:3253:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 ) )
                    // InternalQVTbase.g:3254:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_1());
                    }
                    // InternalQVTbase.g:3255:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_1 )
                    // InternalQVTbase.g:3255:2: rule__ParameterCS__QualifiersAssignment_2_1_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__QualifiersAssignment_2_1_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3259:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 ) )
                    {
                    // InternalQVTbase.g:3259:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 ) )
                    // InternalQVTbase.g:3260:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_2());
                    }
                    // InternalQVTbase.g:3261:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_2 )
                    // InternalQVTbase.g:3261:2: rule__ParameterCS__QualifiersAssignment_2_1_0_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__QualifiersAssignment_2_1_0_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3265:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 ) )
                    {
                    // InternalQVTbase.g:3265:6: ( ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 ) )
                    // InternalQVTbase.g:3266:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_3());
                    }
                    // InternalQVTbase.g:3267:1: ( rule__ParameterCS__QualifiersAssignment_2_1_0_3 )
                    // InternalQVTbase.g:3267:2: rule__ParameterCS__QualifiersAssignment_2_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__QualifiersAssignment_2_1_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getParameterCSAccess().getQualifiersAssignment_2_1_0_3());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Alternatives_2_1_0"


    // $ANTLR start "rule__ReferenceCS__Alternatives_0"
    // InternalQVTbase.g:3276:1: rule__ReferenceCS__Alternatives_0 : ( ( ( rule__ReferenceCS__Group_0_0__0 ) ) | ( ( rule__ReferenceCS__Group_0_1__0 ) ) );
    public final void rule__ReferenceCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3280:1: ( ( ( rule__ReferenceCS__Group_0_0__0 ) ) | ( ( rule__ReferenceCS__Group_0_1__0 ) ) )
            int alt16=2;
            int LA16_0 = input.LA(1);

            if ( (LA16_0==99) ) {
                alt16=1;
            }
            else if ( (LA16_0==100) ) {
                alt16=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 16, 0, input);

                throw nvae;
            }
            switch (alt16) {
                case 1 :
                    // InternalQVTbase.g:3281:1: ( ( rule__ReferenceCS__Group_0_0__0 ) )
                    {
                    // InternalQVTbase.g:3281:1: ( ( rule__ReferenceCS__Group_0_0__0 ) )
                    // InternalQVTbase.g:3282:1: ( rule__ReferenceCS__Group_0_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getGroup_0_0());
                    }
                    // InternalQVTbase.g:3283:1: ( rule__ReferenceCS__Group_0_0__0 )
                    // InternalQVTbase.g:3283:2: rule__ReferenceCS__Group_0_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_0_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getGroup_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3287:6: ( ( rule__ReferenceCS__Group_0_1__0 ) )
                    {
                    // InternalQVTbase.g:3287:6: ( ( rule__ReferenceCS__Group_0_1__0 ) )
                    // InternalQVTbase.g:3288:1: ( rule__ReferenceCS__Group_0_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getGroup_0_1());
                    }
                    // InternalQVTbase.g:3289:1: ( rule__ReferenceCS__Group_0_1__0 )
                    // InternalQVTbase.g:3289:2: rule__ReferenceCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getGroup_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Alternatives_0"


    // $ANTLR start "rule__ReferenceCS__Alternatives_6_1_0"
    // InternalQVTbase.g:3298:1: rule__ReferenceCS__Alternatives_6_1_0 : ( ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 ) ) );
    public final void rule__ReferenceCS__Alternatives_6_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3302:1: ( ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 ) ) | ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 ) ) )
            int alt17=18;
            switch ( input.LA(1) ) {
            case 119:
                {
                alt17=1;
                }
                break;
            case 120:
                {
                alt17=2;
                }
                break;
            case 101:
                {
                alt17=3;
                }
                break;
            case 102:
                {
                alt17=4;
                }
                break;
            case 105:
                {
                alt17=5;
                }
                break;
            case 106:
                {
                alt17=6;
                }
                break;
            case 107:
                {
                alt17=7;
                }
                break;
            case 108:
                {
                alt17=8;
                }
                break;
            case 121:
                {
                alt17=9;
                }
                break;
            case 122:
                {
                alt17=10;
                }
                break;
            case 109:
                {
                alt17=11;
                }
                break;
            case 110:
                {
                alt17=12;
                }
                break;
            case 111:
                {
                alt17=13;
                }
                break;
            case 112:
                {
                alt17=14;
                }
                break;
            case 113:
                {
                alt17=15;
                }
                break;
            case 114:
                {
                alt17=16;
                }
                break;
            case 115:
                {
                alt17=17;
                }
                break;
            case 116:
                {
                alt17=18;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 17, 0, input);

                throw nvae;
            }

            switch (alt17) {
                case 1 :
                    // InternalQVTbase.g:3303:1: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 ) )
                    {
                    // InternalQVTbase.g:3303:1: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 ) )
                    // InternalQVTbase.g:3304:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_0());
                    }
                    // InternalQVTbase.g:3305:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_0 )
                    // InternalQVTbase.g:3305:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3309:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 ) )
                    {
                    // InternalQVTbase.g:3309:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 ) )
                    // InternalQVTbase.g:3310:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_1());
                    }
                    // InternalQVTbase.g:3311:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_1 )
                    // InternalQVTbase.g:3311:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3315:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 ) )
                    {
                    // InternalQVTbase.g:3315:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 ) )
                    // InternalQVTbase.g:3316:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_2());
                    }
                    // InternalQVTbase.g:3317:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_2 )
                    // InternalQVTbase.g:3317:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3321:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 ) )
                    {
                    // InternalQVTbase.g:3321:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 ) )
                    // InternalQVTbase.g:3322:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_3());
                    }
                    // InternalQVTbase.g:3323:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_3 )
                    // InternalQVTbase.g:3323:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:3327:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 ) )
                    {
                    // InternalQVTbase.g:3327:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 ) )
                    // InternalQVTbase.g:3328:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_4());
                    }
                    // InternalQVTbase.g:3329:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_4 )
                    // InternalQVTbase.g:3329:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_4
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_4();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:3333:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 ) )
                    {
                    // InternalQVTbase.g:3333:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 ) )
                    // InternalQVTbase.g:3334:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_5());
                    }
                    // InternalQVTbase.g:3335:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_5 )
                    // InternalQVTbase.g:3335:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_5
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_5();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalQVTbase.g:3339:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 ) )
                    {
                    // InternalQVTbase.g:3339:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 ) )
                    // InternalQVTbase.g:3340:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_6());
                    }
                    // InternalQVTbase.g:3341:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_6 )
                    // InternalQVTbase.g:3341:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_6
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_6();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalQVTbase.g:3345:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 ) )
                    {
                    // InternalQVTbase.g:3345:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 ) )
                    // InternalQVTbase.g:3346:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_7());
                    }
                    // InternalQVTbase.g:3347:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_7 )
                    // InternalQVTbase.g:3347:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_7
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_7();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalQVTbase.g:3351:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 ) )
                    {
                    // InternalQVTbase.g:3351:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 ) )
                    // InternalQVTbase.g:3352:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_8());
                    }
                    // InternalQVTbase.g:3353:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_8 )
                    // InternalQVTbase.g:3353:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_8
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_8();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalQVTbase.g:3357:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 ) )
                    {
                    // InternalQVTbase.g:3357:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 ) )
                    // InternalQVTbase.g:3358:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_9());
                    }
                    // InternalQVTbase.g:3359:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_9 )
                    // InternalQVTbase.g:3359:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_9
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_9();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_9());
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalQVTbase.g:3363:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 ) )
                    {
                    // InternalQVTbase.g:3363:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 ) )
                    // InternalQVTbase.g:3364:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_10());
                    }
                    // InternalQVTbase.g:3365:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_10 )
                    // InternalQVTbase.g:3365:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_10
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_10();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_10());
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalQVTbase.g:3369:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 ) )
                    {
                    // InternalQVTbase.g:3369:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 ) )
                    // InternalQVTbase.g:3370:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_11());
                    }
                    // InternalQVTbase.g:3371:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_11 )
                    // InternalQVTbase.g:3371:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_11
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_11();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_11());
                    }

                    }


                    }
                    break;
                case 13 :
                    // InternalQVTbase.g:3375:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 ) )
                    {
                    // InternalQVTbase.g:3375:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 ) )
                    // InternalQVTbase.g:3376:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_12());
                    }
                    // InternalQVTbase.g:3377:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_12 )
                    // InternalQVTbase.g:3377:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_12
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_12();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_12());
                    }

                    }


                    }
                    break;
                case 14 :
                    // InternalQVTbase.g:3381:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 ) )
                    {
                    // InternalQVTbase.g:3381:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 ) )
                    // InternalQVTbase.g:3382:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_13());
                    }
                    // InternalQVTbase.g:3383:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_13 )
                    // InternalQVTbase.g:3383:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_13
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_13();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_13());
                    }

                    }


                    }
                    break;
                case 15 :
                    // InternalQVTbase.g:3387:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 ) )
                    {
                    // InternalQVTbase.g:3387:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 ) )
                    // InternalQVTbase.g:3388:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_14());
                    }
                    // InternalQVTbase.g:3389:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_14 )
                    // InternalQVTbase.g:3389:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_14
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_14();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_14());
                    }

                    }


                    }
                    break;
                case 16 :
                    // InternalQVTbase.g:3393:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 ) )
                    {
                    // InternalQVTbase.g:3393:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 ) )
                    // InternalQVTbase.g:3394:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_15());
                    }
                    // InternalQVTbase.g:3395:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_15 )
                    // InternalQVTbase.g:3395:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_15
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_15();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_15());
                    }

                    }


                    }
                    break;
                case 17 :
                    // InternalQVTbase.g:3399:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 ) )
                    {
                    // InternalQVTbase.g:3399:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 ) )
                    // InternalQVTbase.g:3400:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_16());
                    }
                    // InternalQVTbase.g:3401:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_16 )
                    // InternalQVTbase.g:3401:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_16
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_16();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_16());
                    }

                    }


                    }
                    break;
                case 18 :
                    // InternalQVTbase.g:3405:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 ) )
                    {
                    // InternalQVTbase.g:3405:6: ( ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 ) )
                    // InternalQVTbase.g:3406:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_17());
                    }
                    // InternalQVTbase.g:3407:1: ( rule__ReferenceCS__QualifiersAssignment_6_1_0_17 )
                    // InternalQVTbase.g:3407:2: rule__ReferenceCS__QualifiersAssignment_6_1_0_17
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_6_1_0_17();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_6_1_0_17());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Alternatives_6_1_0"


    // $ANTLR start "rule__ReferenceCS__Alternatives_7"
    // InternalQVTbase.g:3416:1: rule__ReferenceCS__Alternatives_7 : ( ( ( rule__ReferenceCS__Group_7_0__0 ) ) | ( ';' ) );
    public final void rule__ReferenceCS__Alternatives_7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3420:1: ( ( ( rule__ReferenceCS__Group_7_0__0 ) ) | ( ';' ) )
            int alt18=2;
            int LA18_0 = input.LA(1);

            if ( (LA18_0==62) ) {
                alt18=1;
            }
            else if ( (LA18_0==17) ) {
                alt18=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 18, 0, input);

                throw nvae;
            }
            switch (alt18) {
                case 1 :
                    // InternalQVTbase.g:3421:1: ( ( rule__ReferenceCS__Group_7_0__0 ) )
                    {
                    // InternalQVTbase.g:3421:1: ( ( rule__ReferenceCS__Group_7_0__0 ) )
                    // InternalQVTbase.g:3422:1: ( rule__ReferenceCS__Group_7_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getGroup_7_0());
                    }
                    // InternalQVTbase.g:3423:1: ( rule__ReferenceCS__Group_7_0__0 )
                    // InternalQVTbase.g:3423:2: rule__ReferenceCS__Group_7_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_7_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getGroup_7_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3427:6: ( ';' )
                    {
                    // InternalQVTbase.g:3427:6: ( ';' )
                    // InternalQVTbase.g:3428:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Alternatives_7"


    // $ANTLR start "rule__ReferenceCS__Alternatives_7_0_1"
    // InternalQVTbase.g:3440:1: rule__ReferenceCS__Alternatives_7_0_1 : ( ( ( rule__ReferenceCS__Group_7_0_1_0__0 ) ) | ( ( rule__ReferenceCS__Group_7_0_1_1__0 ) ) );
    public final void rule__ReferenceCS__Alternatives_7_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3444:1: ( ( ( rule__ReferenceCS__Group_7_0_1_0__0 ) ) | ( ( rule__ReferenceCS__Group_7_0_1_1__0 ) ) )
            int alt19=2;
            int LA19_0 = input.LA(1);

            if ( (LA19_0==65) ) {
                alt19=1;
            }
            else if ( (LA19_0==66) ) {
                alt19=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 19, 0, input);

                throw nvae;
            }
            switch (alt19) {
                case 1 :
                    // InternalQVTbase.g:3445:1: ( ( rule__ReferenceCS__Group_7_0_1_0__0 ) )
                    {
                    // InternalQVTbase.g:3445:1: ( ( rule__ReferenceCS__Group_7_0_1_0__0 ) )
                    // InternalQVTbase.g:3446:1: ( rule__ReferenceCS__Group_7_0_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getGroup_7_0_1_0());
                    }
                    // InternalQVTbase.g:3447:1: ( rule__ReferenceCS__Group_7_0_1_0__0 )
                    // InternalQVTbase.g:3447:2: rule__ReferenceCS__Group_7_0_1_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_7_0_1_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getGroup_7_0_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3451:6: ( ( rule__ReferenceCS__Group_7_0_1_1__0 ) )
                    {
                    // InternalQVTbase.g:3451:6: ( ( rule__ReferenceCS__Group_7_0_1_1__0 ) )
                    // InternalQVTbase.g:3452:1: ( rule__ReferenceCS__Group_7_0_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getReferenceCSAccess().getGroup_7_0_1_1());
                    }
                    // InternalQVTbase.g:3453:1: ( rule__ReferenceCS__Group_7_0_1_1__0 )
                    // InternalQVTbase.g:3453:2: rule__ReferenceCS__Group_7_0_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_7_0_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getReferenceCSAccess().getGroup_7_0_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Alternatives_7_0_1"


    // $ANTLR start "rule__SimpleTargetElementCS__Alternatives_0"
    // InternalQVTbase.g:3462:1: rule__SimpleTargetElementCS__Alternatives_0 : ( ( ( rule__SimpleTargetElementCS__InputAssignment_0_0 ) ) | ( ( rule__SimpleTargetElementCS__OutputAssignment_0_1 ) ) | ( ( rule__SimpleTargetElementCS__ViaAssignment_0_2 ) ) );
    public final void rule__SimpleTargetElementCS__Alternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3466:1: ( ( ( rule__SimpleTargetElementCS__InputAssignment_0_0 ) ) | ( ( rule__SimpleTargetElementCS__OutputAssignment_0_1 ) ) | ( ( rule__SimpleTargetElementCS__ViaAssignment_0_2 ) ) )
            int alt20=3;
            switch ( input.LA(1) ) {
            case 123:
                {
                alt20=1;
                }
                break;
            case 124:
                {
                alt20=2;
                }
                break;
            case 125:
                {
                alt20=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 20, 0, input);

                throw nvae;
            }

            switch (alt20) {
                case 1 :
                    // InternalQVTbase.g:3467:1: ( ( rule__SimpleTargetElementCS__InputAssignment_0_0 ) )
                    {
                    // InternalQVTbase.g:3467:1: ( ( rule__SimpleTargetElementCS__InputAssignment_0_0 ) )
                    // InternalQVTbase.g:3468:1: ( rule__SimpleTargetElementCS__InputAssignment_0_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSimpleTargetElementCSAccess().getInputAssignment_0_0());
                    }
                    // InternalQVTbase.g:3469:1: ( rule__SimpleTargetElementCS__InputAssignment_0_0 )
                    // InternalQVTbase.g:3469:2: rule__SimpleTargetElementCS__InputAssignment_0_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__InputAssignment_0_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSimpleTargetElementCSAccess().getInputAssignment_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3473:6: ( ( rule__SimpleTargetElementCS__OutputAssignment_0_1 ) )
                    {
                    // InternalQVTbase.g:3473:6: ( ( rule__SimpleTargetElementCS__OutputAssignment_0_1 ) )
                    // InternalQVTbase.g:3474:1: ( rule__SimpleTargetElementCS__OutputAssignment_0_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSimpleTargetElementCSAccess().getOutputAssignment_0_1());
                    }
                    // InternalQVTbase.g:3475:1: ( rule__SimpleTargetElementCS__OutputAssignment_0_1 )
                    // InternalQVTbase.g:3475:2: rule__SimpleTargetElementCS__OutputAssignment_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__OutputAssignment_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSimpleTargetElementCSAccess().getOutputAssignment_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3479:6: ( ( rule__SimpleTargetElementCS__ViaAssignment_0_2 ) )
                    {
                    // InternalQVTbase.g:3479:6: ( ( rule__SimpleTargetElementCS__ViaAssignment_0_2 ) )
                    // InternalQVTbase.g:3480:1: ( rule__SimpleTargetElementCS__ViaAssignment_0_2 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSimpleTargetElementCSAccess().getViaAssignment_0_2());
                    }
                    // InternalQVTbase.g:3481:1: ( rule__SimpleTargetElementCS__ViaAssignment_0_2 )
                    // InternalQVTbase.g:3481:2: rule__SimpleTargetElementCS__ViaAssignment_0_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__ViaAssignment_0_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSimpleTargetElementCSAccess().getViaAssignment_0_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Alternatives_0"


    // $ANTLR start "rule__SimpleTargetElementCS__Alternatives_2_1"
    // InternalQVTbase.g:3490:1: rule__SimpleTargetElementCS__Alternatives_2_1 : ( ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 ) ) | ( ( rule__SimpleTargetElementCS__Group_2_1_1__0 ) ) );
    public final void rule__SimpleTargetElementCS__Alternatives_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3494:1: ( ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 ) ) | ( ( rule__SimpleTargetElementCS__Group_2_1_1__0 ) ) )
            int alt21=2;
            int LA21_0 = input.LA(1);

            if ( ((LA21_0>=RULE_SIMPLE_ID && LA21_0<=RULE_ESCAPED_ID)) ) {
                alt21=1;
            }
            else if ( (LA21_0==62) ) {
                alt21=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 21, 0, input);

                throw nvae;
            }
            switch (alt21) {
                case 1 :
                    // InternalQVTbase.g:3495:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 ) )
                    {
                    // InternalQVTbase.g:3495:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 ) )
                    // InternalQVTbase.g:3496:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_0());
                    }
                    // InternalQVTbase.g:3497:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 )
                    // InternalQVTbase.g:3497:2: rule__SimpleTargetElementCS__IteratesAssignment_2_1_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__IteratesAssignment_2_1_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3501:6: ( ( rule__SimpleTargetElementCS__Group_2_1_1__0 ) )
                    {
                    // InternalQVTbase.g:3501:6: ( ( rule__SimpleTargetElementCS__Group_2_1_1__0 ) )
                    // InternalQVTbase.g:3502:1: ( rule__SimpleTargetElementCS__Group_2_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1());
                    }
                    // InternalQVTbase.g:3503:1: ( rule__SimpleTargetElementCS__Group_2_1_1__0 )
                    // InternalQVTbase.g:3503:2: rule__SimpleTargetElementCS__Group_2_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__Group_2_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Alternatives_2_1"


    // $ANTLR start "rule__SpecificationCS__Alternatives"
    // InternalQVTbase.g:3512:1: rule__SpecificationCS__Alternatives : ( ( ( rule__SpecificationCS__OwnedExpressionAssignment_0 ) ) | ( ( rule__SpecificationCS__ExprStringAssignment_1 ) ) );
    public final void rule__SpecificationCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3516:1: ( ( ( rule__SpecificationCS__OwnedExpressionAssignment_0 ) ) | ( ( rule__SpecificationCS__ExprStringAssignment_1 ) ) )
            int alt22=2;
            int LA22_0 = input.LA(1);

            if ( ((LA22_0>=RULE_INT && LA22_0<=RULE_ESCAPED_ID)||(LA22_0>=19 && LA22_0<=22)||(LA22_0>=43 && LA22_0<=57)||LA22_0==71||LA22_0==82||(LA22_0>=84 && LA22_0<=85)||LA22_0==90||(LA22_0>=95 && LA22_0<=96)||(LA22_0>=128 && LA22_0<=129)) ) {
                alt22=1;
            }
            else if ( (LA22_0==RULE_UNQUOTED_STRING) ) {
                alt22=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 22, 0, input);

                throw nvae;
            }
            switch (alt22) {
                case 1 :
                    // InternalQVTbase.g:3517:1: ( ( rule__SpecificationCS__OwnedExpressionAssignment_0 ) )
                    {
                    // InternalQVTbase.g:3517:1: ( ( rule__SpecificationCS__OwnedExpressionAssignment_0 ) )
                    // InternalQVTbase.g:3518:1: ( rule__SpecificationCS__OwnedExpressionAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSpecificationCSAccess().getOwnedExpressionAssignment_0());
                    }
                    // InternalQVTbase.g:3519:1: ( rule__SpecificationCS__OwnedExpressionAssignment_0 )
                    // InternalQVTbase.g:3519:2: rule__SpecificationCS__OwnedExpressionAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SpecificationCS__OwnedExpressionAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSpecificationCSAccess().getOwnedExpressionAssignment_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3523:6: ( ( rule__SpecificationCS__ExprStringAssignment_1 ) )
                    {
                    // InternalQVTbase.g:3523:6: ( ( rule__SpecificationCS__ExprStringAssignment_1 ) )
                    // InternalQVTbase.g:3524:1: ( rule__SpecificationCS__ExprStringAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getSpecificationCSAccess().getExprStringAssignment_1());
                    }
                    // InternalQVTbase.g:3525:1: ( rule__SpecificationCS__ExprStringAssignment_1 )
                    // InternalQVTbase.g:3525:2: rule__SpecificationCS__ExprStringAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SpecificationCS__ExprStringAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getSpecificationCSAccess().getExprStringAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SpecificationCS__Alternatives"


    // $ANTLR start "rule__StructuredClassCS__Alternatives_7"
    // InternalQVTbase.g:3534:1: rule__StructuredClassCS__Alternatives_7 : ( ( ( rule__StructuredClassCS__Group_7_0__0 ) ) | ( ';' ) );
    public final void rule__StructuredClassCS__Alternatives_7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3538:1: ( ( ( rule__StructuredClassCS__Group_7_0__0 ) ) | ( ';' ) )
            int alt23=2;
            int LA23_0 = input.LA(1);

            if ( (LA23_0==62) ) {
                alt23=1;
            }
            else if ( (LA23_0==17) ) {
                alt23=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 23, 0, input);

                throw nvae;
            }
            switch (alt23) {
                case 1 :
                    // InternalQVTbase.g:3539:1: ( ( rule__StructuredClassCS__Group_7_0__0 ) )
                    {
                    // InternalQVTbase.g:3539:1: ( ( rule__StructuredClassCS__Group_7_0__0 ) )
                    // InternalQVTbase.g:3540:1: ( rule__StructuredClassCS__Group_7_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuredClassCSAccess().getGroup_7_0());
                    }
                    // InternalQVTbase.g:3541:1: ( rule__StructuredClassCS__Group_7_0__0 )
                    // InternalQVTbase.g:3541:2: rule__StructuredClassCS__Group_7_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__Group_7_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuredClassCSAccess().getGroup_7_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3545:6: ( ';' )
                    {
                    // InternalQVTbase.g:3545:6: ( ';' )
                    // InternalQVTbase.g:3546:1: ';'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuredClassCSAccess().getSemicolonKeyword_7_1());
                    }
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuredClassCSAccess().getSemicolonKeyword_7_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Alternatives_7"


    // $ANTLR start "rule__StructuredClassCS__Alternatives_7_0_1"
    // InternalQVTbase.g:3558:1: rule__StructuredClassCS__Alternatives_7_0_1 : ( ( ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 ) ) | ( ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 ) ) );
    public final void rule__StructuredClassCS__Alternatives_7_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3562:1: ( ( ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 ) ) | ( ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 ) ) )
            int alt24=2;
            switch ( input.LA(1) ) {
            case 99:
                {
                switch ( input.LA(2) ) {
                case 100:
                    {
                    int LA24_5 = input.LA(3);

                    if ( (LA24_5==60||LA24_5==75) ) {
                        alt24=2;
                    }
                    else if ( (LA24_5==70) ) {
                        alt24=1;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 24, 5, input);

                        throw nvae;
                    }
                    }
                    break;
                case 60:
                case 75:
                    {
                    alt24=2;
                    }
                    break;
                case 70:
                    {
                    alt24=1;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 24, 1, input);

                    throw nvae;
                }

                }
                break;
            case 100:
                {
                switch ( input.LA(2) ) {
                case 99:
                    {
                    int LA24_6 = input.LA(3);

                    if ( (LA24_6==70) ) {
                        alt24=1;
                    }
                    else if ( (LA24_6==60||LA24_6==75) ) {
                        alt24=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 24, 6, input);

                        throw nvae;
                    }
                    }
                    break;
                case 60:
                case 75:
                    {
                    alt24=2;
                    }
                    break;
                case 70:
                    {
                    alt24=1;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 24, 2, input);

                    throw nvae;
                }

                }
                break;
            case 70:
                {
                alt24=1;
                }
                break;
            case 60:
            case 75:
                {
                alt24=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 24, 0, input);

                throw nvae;
            }

            switch (alt24) {
                case 1 :
                    // InternalQVTbase.g:3563:1: ( ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 ) )
                    {
                    // InternalQVTbase.g:3563:1: ( ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 ) )
                    // InternalQVTbase.g:3564:1: ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuredClassCSAccess().getOwnedOperationsAssignment_7_0_1_0());
                    }
                    // InternalQVTbase.g:3565:1: ( rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 )
                    // InternalQVTbase.g:3565:2: rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuredClassCSAccess().getOwnedOperationsAssignment_7_0_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3569:6: ( ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 ) )
                    {
                    // InternalQVTbase.g:3569:6: ( ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 ) )
                    // InternalQVTbase.g:3570:1: ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuredClassCSAccess().getOwnedPropertiesAssignment_7_0_1_1());
                    }
                    // InternalQVTbase.g:3571:1: ( rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 )
                    // InternalQVTbase.g:3571:2: rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuredClassCSAccess().getOwnedPropertiesAssignment_7_0_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Alternatives_7_0_1"


    // $ANTLR start "rule__TypedRefCS__Alternatives"
    // InternalQVTbase.g:3581:1: rule__TypedRefCS__Alternatives : ( ( ruleTypeLiteralCS ) | ( ruleTypedTypeRefCS ) );
    public final void rule__TypedRefCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3585:1: ( ( ruleTypeLiteralCS ) | ( ruleTypedTypeRefCS ) )
            int alt25=2;
            int LA25_0 = input.LA(1);

            if ( ((LA25_0>=43 && LA25_0<=57)) ) {
                alt25=1;
            }
            else if ( ((LA25_0>=RULE_SIMPLE_ID && LA25_0<=RULE_ESCAPED_ID)) ) {
                alt25=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 25, 0, input);

                throw nvae;
            }
            switch (alt25) {
                case 1 :
                    // InternalQVTbase.g:3586:1: ( ruleTypeLiteralCS )
                    {
                    // InternalQVTbase.g:3586:1: ( ruleTypeLiteralCS )
                    // InternalQVTbase.g:3587:1: ruleTypeLiteralCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypedRefCSAccess().getTypeLiteralCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeLiteralCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypedRefCSAccess().getTypeLiteralCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3592:6: ( ruleTypedTypeRefCS )
                    {
                    // InternalQVTbase.g:3592:6: ( ruleTypedTypeRefCS )
                    // InternalQVTbase.g:3593:1: ruleTypedTypeRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypedTypeRefCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypedRefCSAccess().getTypedTypeRefCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedRefCS__Alternatives"


    // $ANTLR start "rule__StructuralFeatureCS__Alternatives"
    // InternalQVTbase.g:3603:1: rule__StructuralFeatureCS__Alternatives : ( ( ruleAttributeCS ) | ( ruleReferenceCS ) );
    public final void rule__StructuralFeatureCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3607:1: ( ( ruleAttributeCS ) | ( ruleReferenceCS ) )
            int alt26=2;
            switch ( input.LA(1) ) {
            case 99:
                {
                switch ( input.LA(2) ) {
                case 100:
                    {
                    int LA26_5 = input.LA(3);

                    if ( (LA26_5==60) ) {
                        alt26=1;
                    }
                    else if ( (LA26_5==75) ) {
                        alt26=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 26, 5, input);

                        throw nvae;
                    }
                    }
                    break;
                case 75:
                    {
                    alt26=2;
                    }
                    break;
                case 60:
                    {
                    alt26=1;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 26, 1, input);

                    throw nvae;
                }

                }
                break;
            case 100:
                {
                switch ( input.LA(2) ) {
                case 99:
                    {
                    int LA26_6 = input.LA(3);

                    if ( (LA26_6==60) ) {
                        alt26=1;
                    }
                    else if ( (LA26_6==75) ) {
                        alt26=2;
                    }
                    else {
                        if (state.backtracking>0) {state.failed=true; return ;}
                        NoViableAltException nvae =
                            new NoViableAltException("", 26, 6, input);

                        throw nvae;
                    }
                    }
                    break;
                case 75:
                    {
                    alt26=2;
                    }
                    break;
                case 60:
                    {
                    alt26=1;
                    }
                    break;
                default:
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 26, 2, input);

                    throw nvae;
                }

                }
                break;
            case 60:
                {
                alt26=1;
                }
                break;
            case 75:
                {
                alt26=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 26, 0, input);

                throw nvae;
            }

            switch (alt26) {
                case 1 :
                    // InternalQVTbase.g:3608:1: ( ruleAttributeCS )
                    {
                    // InternalQVTbase.g:3608:1: ( ruleAttributeCS )
                    // InternalQVTbase.g:3609:1: ruleAttributeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuralFeatureCSAccess().getAttributeCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleAttributeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuralFeatureCSAccess().getAttributeCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3614:6: ( ruleReferenceCS )
                    {
                    // InternalQVTbase.g:3614:6: ( ruleReferenceCS )
                    // InternalQVTbase.g:3615:1: ruleReferenceCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getStructuralFeatureCSAccess().getReferenceCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleReferenceCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getStructuralFeatureCSAccess().getReferenceCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuralFeatureCS__Alternatives"


    // $ANTLR start "rule__EssentialOCLUnaryOperatorName__Alternatives"
    // InternalQVTbase.g:3627:1: rule__EssentialOCLUnaryOperatorName__Alternatives : ( ( '-' ) | ( 'not' ) | ( 'not2' ) );
    public final void rule__EssentialOCLUnaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3631:1: ( ( '-' ) | ( 'not' ) | ( 'not2' ) )
            int alt27=3;
            switch ( input.LA(1) ) {
            case 19:
                {
                alt27=1;
                }
                break;
            case 20:
                {
                alt27=2;
                }
                break;
            case 21:
                {
                alt27=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 27, 0, input);

                throw nvae;
            }

            switch (alt27) {
                case 1 :
                    // InternalQVTbase.g:3632:1: ( '-' )
                    {
                    // InternalQVTbase.g:3632:1: ( '-' )
                    // InternalQVTbase.g:3633:1: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0());
                    }
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getHyphenMinusKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3640:6: ( 'not' )
                    {
                    // InternalQVTbase.g:3640:6: ( 'not' )
                    // InternalQVTbase.g:3641:1: 'not'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1());
                    }
                    match(input,20,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNotKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3648:6: ( 'not2' )
                    {
                    // InternalQVTbase.g:3648:6: ( 'not2' )
                    // InternalQVTbase.g:3649:1: 'not2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2());
                    }
                    match(input,21,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnaryOperatorNameAccess().getNot2Keyword_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLUnaryOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLInfixOperatorName__Alternatives"
    // InternalQVTbase.g:3661:1: rule__EssentialOCLInfixOperatorName__Alternatives : ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) );
    public final void rule__EssentialOCLInfixOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3665:1: ( ( '*' ) | ( '/' ) | ( '+' ) | ( '-' ) | ( '>' ) | ( '<' ) | ( '>=' ) | ( '<=' ) | ( '=' ) | ( '<>' ) | ( 'and' ) | ( 'and2' ) | ( 'implies' ) | ( 'implies2' ) | ( 'or' ) | ( 'or2' ) | ( 'xor' ) | ( 'xor2' ) )
            int alt28=18;
            switch ( input.LA(1) ) {
            case 22:
                {
                alt28=1;
                }
                break;
            case 23:
                {
                alt28=2;
                }
                break;
            case 24:
                {
                alt28=3;
                }
                break;
            case 19:
                {
                alt28=4;
                }
                break;
            case 25:
                {
                alt28=5;
                }
                break;
            case 26:
                {
                alt28=6;
                }
                break;
            case 27:
                {
                alt28=7;
                }
                break;
            case 28:
                {
                alt28=8;
                }
                break;
            case 29:
                {
                alt28=9;
                }
                break;
            case 30:
                {
                alt28=10;
                }
                break;
            case 31:
                {
                alt28=11;
                }
                break;
            case 32:
                {
                alt28=12;
                }
                break;
            case 33:
                {
                alt28=13;
                }
                break;
            case 34:
                {
                alt28=14;
                }
                break;
            case 35:
                {
                alt28=15;
                }
                break;
            case 36:
                {
                alt28=16;
                }
                break;
            case 37:
                {
                alt28=17;
                }
                break;
            case 38:
                {
                alt28=18;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 28, 0, input);

                throw nvae;
            }

            switch (alt28) {
                case 1 :
                    // InternalQVTbase.g:3666:1: ( '*' )
                    {
                    // InternalQVTbase.g:3666:1: ( '*' )
                    // InternalQVTbase.g:3667:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0());
                    }
                    match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAsteriskKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3674:6: ( '/' )
                    {
                    // InternalQVTbase.g:3674:6: ( '/' )
                    // InternalQVTbase.g:3675:1: '/'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1());
                    }
                    match(input,23,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getSolidusKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3682:6: ( '+' )
                    {
                    // InternalQVTbase.g:3682:6: ( '+' )
                    // InternalQVTbase.g:3683:1: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2());
                    }
                    match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getPlusSignKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3690:6: ( '-' )
                    {
                    // InternalQVTbase.g:3690:6: ( '-' )
                    // InternalQVTbase.g:3691:1: '-'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3());
                    }
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getHyphenMinusKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:3698:6: ( '>' )
                    {
                    // InternalQVTbase.g:3698:6: ( '>' )
                    // InternalQVTbase.g:3699:1: '>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4());
                    }
                    match(input,25,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignKeyword_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:3706:6: ( '<' )
                    {
                    // InternalQVTbase.g:3706:6: ( '<' )
                    // InternalQVTbase.g:3707:1: '<'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5());
                    }
                    match(input,26,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignKeyword_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalQVTbase.g:3714:6: ( '>=' )
                    {
                    // InternalQVTbase.g:3714:6: ( '>=' )
                    // InternalQVTbase.g:3715:1: '>='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6());
                    }
                    match(input,27,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getGreaterThanSignEqualsSignKeyword_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalQVTbase.g:3722:6: ( '<=' )
                    {
                    // InternalQVTbase.g:3722:6: ( '<=' )
                    // InternalQVTbase.g:3723:1: '<='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7());
                    }
                    match(input,28,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignEqualsSignKeyword_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalQVTbase.g:3730:6: ( '=' )
                    {
                    // InternalQVTbase.g:3730:6: ( '=' )
                    // InternalQVTbase.g:3731:1: '='
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8());
                    }
                    match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getEqualsSignKeyword_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalQVTbase.g:3738:6: ( '<>' )
                    {
                    // InternalQVTbase.g:3738:6: ( '<>' )
                    // InternalQVTbase.g:3739:1: '<>'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9());
                    }
                    match(input,30,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getLessThanSignGreaterThanSignKeyword_9());
                    }

                    }


                    }
                    break;
                case 11 :
                    // InternalQVTbase.g:3746:6: ( 'and' )
                    {
                    // InternalQVTbase.g:3746:6: ( 'and' )
                    // InternalQVTbase.g:3747:1: 'and'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10());
                    }
                    match(input,31,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAndKeyword_10());
                    }

                    }


                    }
                    break;
                case 12 :
                    // InternalQVTbase.g:3754:6: ( 'and2' )
                    {
                    // InternalQVTbase.g:3754:6: ( 'and2' )
                    // InternalQVTbase.g:3755:1: 'and2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11());
                    }
                    match(input,32,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getAnd2Keyword_11());
                    }

                    }


                    }
                    break;
                case 13 :
                    // InternalQVTbase.g:3762:6: ( 'implies' )
                    {
                    // InternalQVTbase.g:3762:6: ( 'implies' )
                    // InternalQVTbase.g:3763:1: 'implies'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12());
                    }
                    match(input,33,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImpliesKeyword_12());
                    }

                    }


                    }
                    break;
                case 14 :
                    // InternalQVTbase.g:3770:6: ( 'implies2' )
                    {
                    // InternalQVTbase.g:3770:6: ( 'implies2' )
                    // InternalQVTbase.g:3771:1: 'implies2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13());
                    }
                    match(input,34,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getImplies2Keyword_13());
                    }

                    }


                    }
                    break;
                case 15 :
                    // InternalQVTbase.g:3778:6: ( 'or' )
                    {
                    // InternalQVTbase.g:3778:6: ( 'or' )
                    // InternalQVTbase.g:3779:1: 'or'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14());
                    }
                    match(input,35,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOrKeyword_14());
                    }

                    }


                    }
                    break;
                case 16 :
                    // InternalQVTbase.g:3786:6: ( 'or2' )
                    {
                    // InternalQVTbase.g:3786:6: ( 'or2' )
                    // InternalQVTbase.g:3787:1: 'or2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15());
                    }
                    match(input,36,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getOr2Keyword_15());
                    }

                    }


                    }
                    break;
                case 17 :
                    // InternalQVTbase.g:3794:6: ( 'xor' )
                    {
                    // InternalQVTbase.g:3794:6: ( 'xor' )
                    // InternalQVTbase.g:3795:1: 'xor'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16());
                    }
                    match(input,37,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXorKeyword_16());
                    }

                    }


                    }
                    break;
                case 18 :
                    // InternalQVTbase.g:3802:6: ( 'xor2' )
                    {
                    // InternalQVTbase.g:3802:6: ( 'xor2' )
                    // InternalQVTbase.g:3803:1: 'xor2'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17());
                    }
                    match(input,38,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLInfixOperatorNameAccess().getXor2Keyword_17());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLInfixOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLNavigationOperatorName__Alternatives"
    // InternalQVTbase.g:3815:1: rule__EssentialOCLNavigationOperatorName__Alternatives : ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) );
    public final void rule__EssentialOCLNavigationOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3819:1: ( ( '.' ) | ( '->' ) | ( '?.' ) | ( '?->' ) )
            int alt29=4;
            switch ( input.LA(1) ) {
            case 39:
                {
                alt29=1;
                }
                break;
            case 40:
                {
                alt29=2;
                }
                break;
            case 41:
                {
                alt29=3;
                }
                break;
            case 42:
                {
                alt29=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 29, 0, input);

                throw nvae;
            }

            switch (alt29) {
                case 1 :
                    // InternalQVTbase.g:3820:1: ( '.' )
                    {
                    // InternalQVTbase.g:3820:1: ( '.' )
                    // InternalQVTbase.g:3821:1: '.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0());
                    }
                    match(input,39,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getFullStopKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3828:6: ( '->' )
                    {
                    // InternalQVTbase.g:3828:6: ( '->' )
                    // InternalQVTbase.g:3829:1: '->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1());
                    }
                    match(input,40,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getHyphenMinusGreaterThanSignKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3836:6: ( '?.' )
                    {
                    // InternalQVTbase.g:3836:6: ( '?.' )
                    // InternalQVTbase.g:3837:1: '?.'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2());
                    }
                    match(input,41,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkFullStopKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3844:6: ( '?->' )
                    {
                    // InternalQVTbase.g:3844:6: ( '?->' )
                    // InternalQVTbase.g:3845:1: '?->'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3());
                    }
                    match(input,42,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLNavigationOperatorNameAccess().getQuestionMarkHyphenMinusGreaterThanSignKeyword_3());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLNavigationOperatorName__Alternatives"


    // $ANTLR start "rule__BinaryOperatorName__Alternatives"
    // InternalQVTbase.g:3857:1: rule__BinaryOperatorName__Alternatives : ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) );
    public final void rule__BinaryOperatorName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3861:1: ( ( ruleInfixOperatorName ) | ( ruleNavigationOperatorName ) )
            int alt30=2;
            int LA30_0 = input.LA(1);

            if ( (LA30_0==19||(LA30_0>=22 && LA30_0<=38)) ) {
                alt30=1;
            }
            else if ( ((LA30_0>=39 && LA30_0<=42)) ) {
                alt30=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 30, 0, input);

                throw nvae;
            }
            switch (alt30) {
                case 1 :
                    // InternalQVTbase.g:3862:1: ( ruleInfixOperatorName )
                    {
                    // InternalQVTbase.g:3862:1: ( ruleInfixOperatorName )
                    // InternalQVTbase.g:3863:1: ruleInfixOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleInfixOperatorName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBinaryOperatorNameAccess().getInfixOperatorNameParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3868:6: ( ruleNavigationOperatorName )
                    {
                    // InternalQVTbase.g:3868:6: ( ruleNavigationOperatorName )
                    // InternalQVTbase.g:3869:1: ruleNavigationOperatorName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigationOperatorName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBinaryOperatorNameAccess().getNavigationOperatorNameParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BinaryOperatorName__Alternatives"


    // $ANTLR start "rule__EssentialOCLUnreservedName__Alternatives"
    // InternalQVTbase.g:3879:1: rule__EssentialOCLUnreservedName__Alternatives : ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) );
    public final void rule__EssentialOCLUnreservedName__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3883:1: ( ( ruleUnrestrictedName ) | ( ruleCollectionTypeIdentifier ) | ( rulePrimitiveTypeIdentifier ) | ( 'Map' ) | ( 'Tuple' ) )
            int alt31=5;
            switch ( input.LA(1) ) {
            case RULE_SIMPLE_ID:
            case RULE_ESCAPED_ID:
                {
                alt31=1;
                }
                break;
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
                {
                alt31=2;
                }
                break;
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
                {
                alt31=3;
                }
                break;
            case 43:
                {
                alt31=4;
                }
                break;
            case 44:
                {
                alt31=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 31, 0, input);

                throw nvae;
            }

            switch (alt31) {
                case 1 :
                    // InternalQVTbase.g:3884:1: ( ruleUnrestrictedName )
                    {
                    // InternalQVTbase.g:3884:1: ( ruleUnrestrictedName )
                    // InternalQVTbase.g:3885:1: ruleUnrestrictedName
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getUnrestrictedNameParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3890:6: ( ruleCollectionTypeIdentifier )
                    {
                    // InternalQVTbase.g:3890:6: ( ruleCollectionTypeIdentifier )
                    // InternalQVTbase.g:3891:1: ruleCollectionTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionTypeIdentifier();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getCollectionTypeIdentifierParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3896:6: ( rulePrimitiveTypeIdentifier )
                    {
                    // InternalQVTbase.g:3896:6: ( rulePrimitiveTypeIdentifier )
                    // InternalQVTbase.g:3897:1: rulePrimitiveTypeIdentifier
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveTypeIdentifier();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getPrimitiveTypeIdentifierParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3902:6: ( 'Map' )
                    {
                    // InternalQVTbase.g:3902:6: ( 'Map' )
                    // InternalQVTbase.g:3903:1: 'Map'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3());
                    }
                    match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getMapKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:3910:6: ( 'Tuple' )
                    {
                    // InternalQVTbase.g:3910:6: ( 'Tuple' )
                    // InternalQVTbase.g:3911:1: 'Tuple'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4());
                    }
                    match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getEssentialOCLUnreservedNameAccess().getTupleKeyword_4());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EssentialOCLUnreservedName__Alternatives"


    // $ANTLR start "rule__URIFirstPathElementCS__Alternatives"
    // InternalQVTbase.g:3923:1: rule__URIFirstPathElementCS__Alternatives : ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) );
    public final void rule__URIFirstPathElementCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3927:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) ) | ( ( rule__URIFirstPathElementCS__Group_1__0 ) ) )
            int alt32=2;
            int LA32_0 = input.LA(1);

            if ( ((LA32_0>=RULE_SIMPLE_ID && LA32_0<=RULE_ESCAPED_ID)) ) {
                alt32=1;
            }
            else if ( (LA32_0==RULE_SINGLE_QUOTED_STRING) ) {
                alt32=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 32, 0, input);

                throw nvae;
            }
            switch (alt32) {
                case 1 :
                    // InternalQVTbase.g:3928:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    {
                    // InternalQVTbase.g:3928:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 ) )
                    // InternalQVTbase.g:3929:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0());
                    }
                    // InternalQVTbase.g:3930:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_0 )
                    // InternalQVTbase.g:3930:2: rule__URIFirstPathElementCS__ReferredElementAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__URIFirstPathElementCS__ReferredElementAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3934:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    {
                    // InternalQVTbase.g:3934:6: ( ( rule__URIFirstPathElementCS__Group_1__0 ) )
                    // InternalQVTbase.g:3935:1: ( rule__URIFirstPathElementCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1());
                    }
                    // InternalQVTbase.g:3936:1: ( rule__URIFirstPathElementCS__Group_1__0 )
                    // InternalQVTbase.g:3936:2: rule__URIFirstPathElementCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__URIFirstPathElementCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getURIFirstPathElementCSAccess().getGroup_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Alternatives"


    // $ANTLR start "rule__PrimitiveTypeIdentifier__Alternatives"
    // InternalQVTbase.g:3945:1: rule__PrimitiveTypeIdentifier__Alternatives : ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) );
    public final void rule__PrimitiveTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:3949:1: ( ( 'Boolean' ) | ( 'Integer' ) | ( 'Real' ) | ( 'String' ) | ( 'UnlimitedNatural' ) | ( 'OclAny' ) | ( 'OclInvalid' ) | ( 'OclVoid' ) )
            int alt33=8;
            switch ( input.LA(1) ) {
            case 45:
                {
                alt33=1;
                }
                break;
            case 46:
                {
                alt33=2;
                }
                break;
            case 47:
                {
                alt33=3;
                }
                break;
            case 48:
                {
                alt33=4;
                }
                break;
            case 49:
                {
                alt33=5;
                }
                break;
            case 50:
                {
                alt33=6;
                }
                break;
            case 51:
                {
                alt33=7;
                }
                break;
            case 52:
                {
                alt33=8;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 33, 0, input);

                throw nvae;
            }

            switch (alt33) {
                case 1 :
                    // InternalQVTbase.g:3950:1: ( 'Boolean' )
                    {
                    // InternalQVTbase.g:3950:1: ( 'Boolean' )
                    // InternalQVTbase.g:3951:1: 'Boolean'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0());
                    }
                    match(input,45,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getBooleanKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:3958:6: ( 'Integer' )
                    {
                    // InternalQVTbase.g:3958:6: ( 'Integer' )
                    // InternalQVTbase.g:3959:1: 'Integer'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1());
                    }
                    match(input,46,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getIntegerKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:3966:6: ( 'Real' )
                    {
                    // InternalQVTbase.g:3966:6: ( 'Real' )
                    // InternalQVTbase.g:3967:1: 'Real'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2());
                    }
                    match(input,47,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getRealKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:3974:6: ( 'String' )
                    {
                    // InternalQVTbase.g:3974:6: ( 'String' )
                    // InternalQVTbase.g:3975:1: 'String'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3());
                    }
                    match(input,48,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getStringKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:3982:6: ( 'UnlimitedNatural' )
                    {
                    // InternalQVTbase.g:3982:6: ( 'UnlimitedNatural' )
                    // InternalQVTbase.g:3983:1: 'UnlimitedNatural'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4());
                    }
                    match(input,49,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getUnlimitedNaturalKeyword_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:3990:6: ( 'OclAny' )
                    {
                    // InternalQVTbase.g:3990:6: ( 'OclAny' )
                    // InternalQVTbase.g:3991:1: 'OclAny'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5());
                    }
                    match(input,50,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclAnyKeyword_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalQVTbase.g:3998:6: ( 'OclInvalid' )
                    {
                    // InternalQVTbase.g:3998:6: ( 'OclInvalid' )
                    // InternalQVTbase.g:3999:1: 'OclInvalid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6());
                    }
                    match(input,51,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclInvalidKeyword_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalQVTbase.g:4006:6: ( 'OclVoid' )
                    {
                    // InternalQVTbase.g:4006:6: ( 'OclVoid' )
                    // InternalQVTbase.g:4007:1: 'OclVoid'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7());
                    }
                    match(input,52,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveTypeIdentifierAccess().getOclVoidKeyword_7());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveTypeIdentifier__Alternatives"


    // $ANTLR start "rule__CollectionTypeIdentifier__Alternatives"
    // InternalQVTbase.g:4019:1: rule__CollectionTypeIdentifier__Alternatives : ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) );
    public final void rule__CollectionTypeIdentifier__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4023:1: ( ( 'Set' ) | ( 'Bag' ) | ( 'Sequence' ) | ( 'Collection' ) | ( 'OrderedSet' ) )
            int alt34=5;
            switch ( input.LA(1) ) {
            case 53:
                {
                alt34=1;
                }
                break;
            case 54:
                {
                alt34=2;
                }
                break;
            case 55:
                {
                alt34=3;
                }
                break;
            case 56:
                {
                alt34=4;
                }
                break;
            case 57:
                {
                alt34=5;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 34, 0, input);

                throw nvae;
            }

            switch (alt34) {
                case 1 :
                    // InternalQVTbase.g:4024:1: ( 'Set' )
                    {
                    // InternalQVTbase.g:4024:1: ( 'Set' )
                    // InternalQVTbase.g:4025:1: 'Set'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0());
                    }
                    match(input,53,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSetKeyword_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4032:6: ( 'Bag' )
                    {
                    // InternalQVTbase.g:4032:6: ( 'Bag' )
                    // InternalQVTbase.g:4033:1: 'Bag'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1());
                    }
                    match(input,54,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getBagKeyword_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4040:6: ( 'Sequence' )
                    {
                    // InternalQVTbase.g:4040:6: ( 'Sequence' )
                    // InternalQVTbase.g:4041:1: 'Sequence'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2());
                    }
                    match(input,55,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getSequenceKeyword_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:4048:6: ( 'Collection' )
                    {
                    // InternalQVTbase.g:4048:6: ( 'Collection' )
                    // InternalQVTbase.g:4049:1: 'Collection'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3());
                    }
                    match(input,56,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getCollectionKeyword_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:4056:6: ( 'OrderedSet' )
                    {
                    // InternalQVTbase.g:4056:6: ( 'OrderedSet' )
                    // InternalQVTbase.g:4057:1: 'OrderedSet'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4());
                    }
                    match(input,57,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionTypeIdentifierAccess().getOrderedSetKeyword_4());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeIdentifier__Alternatives"


    // $ANTLR start "rule__CollectionLiteralPartCS__Alternatives"
    // InternalQVTbase.g:4069:1: rule__CollectionLiteralPartCS__Alternatives : ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) );
    public final void rule__CollectionLiteralPartCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4073:1: ( ( ( rule__CollectionLiteralPartCS__Group_0__0 ) ) | ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) ) )
            int alt35=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 19:
            case 20:
            case 21:
            case 22:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 71:
            case 82:
            case 84:
            case 85:
            case 90:
            case 95:
            case 96:
            case 128:
            case 129:
                {
                alt35=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA35_2 = input.LA(2);

                if ( (LA35_2==EOF||LA35_2==19||(LA35_2>=22 && LA35_2<=42)||(LA35_2>=62 && LA35_2<=64)||LA35_2==71||LA35_2==80||LA35_2==87||LA35_2==97||LA35_2==130) ) {
                    alt35=1;
                }
                else if ( (LA35_2==61) ) {
                    alt35=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 35, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA35_3 = input.LA(2);

                if ( (LA35_3==61) ) {
                    alt35=2;
                }
                else if ( (LA35_3==EOF||LA35_3==19||(LA35_3>=22 && LA35_3<=42)||(LA35_3>=62 && LA35_3<=64)||LA35_3==71||LA35_3==80||LA35_3==87||LA35_3==97||LA35_3==130) ) {
                    alt35=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 35, 3, input);

                    throw nvae;
                }
                }
                break;
            case 61:
                {
                alt35=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 35, 0, input);

                throw nvae;
            }

            switch (alt35) {
                case 1 :
                    // InternalQVTbase.g:4074:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4074:1: ( ( rule__CollectionLiteralPartCS__Group_0__0 ) )
                    // InternalQVTbase.g:4075:1: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4076:1: ( rule__CollectionLiteralPartCS__Group_0__0 )
                    // InternalQVTbase.g:4076:2: rule__CollectionLiteralPartCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4080:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    {
                    // InternalQVTbase.g:4080:6: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 ) )
                    // InternalQVTbase.g:4081:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1());
                    }
                    // InternalQVTbase.g:4082:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 )
                    // InternalQVTbase.g:4082:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Alternatives"


    // $ANTLR start "rule__ShadowPartCS__Alternatives"
    // InternalQVTbase.g:4091:1: rule__ShadowPartCS__Alternatives : ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) );
    public final void rule__ShadowPartCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4095:1: ( ( ( rule__ShadowPartCS__Group_0__0 ) ) | ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) ) )
            int alt36=2;
            int LA36_0 = input.LA(1);

            if ( ((LA36_0>=RULE_SIMPLE_ID && LA36_0<=RULE_ESCAPED_ID)) ) {
                alt36=1;
            }
            else if ( (LA36_0==RULE_SINGLE_QUOTED_STRING) ) {
                alt36=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 36, 0, input);

                throw nvae;
            }
            switch (alt36) {
                case 1 :
                    // InternalQVTbase.g:4096:1: ( ( rule__ShadowPartCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4096:1: ( ( rule__ShadowPartCS__Group_0__0 ) )
                    // InternalQVTbase.g:4097:1: ( rule__ShadowPartCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4098:1: ( rule__ShadowPartCS__Group_0__0 )
                    // InternalQVTbase.g:4098:2: rule__ShadowPartCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ShadowPartCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4102:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) )
                    {
                    // InternalQVTbase.g:4102:6: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 ) )
                    // InternalQVTbase.g:4103:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1());
                    }
                    // InternalQVTbase.g:4104:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_1 )
                    // InternalQVTbase.g:4104:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ShadowPartCS__OwnedInitExpressionAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Alternatives"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0"
    // InternalQVTbase.g:4113:1: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4117:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt37=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 19:
            case 20:
            case 21:
            case 22:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 71:
            case 82:
            case 84:
            case 85:
            case 90:
            case 95:
            case 96:
            case 128:
            case 129:
                {
                alt37=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA37_2 = input.LA(2);

                if ( (LA37_2==61) ) {
                    alt37=2;
                }
                else if ( (LA37_2==EOF||LA37_2==19||(LA37_2>=22 && LA37_2<=42)||(LA37_2>=62 && LA37_2<=64)||LA37_2==71||LA37_2==87||LA37_2==97||LA37_2==130) ) {
                    alt37=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 37, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA37_3 = input.LA(2);

                if ( (LA37_3==EOF||LA37_3==19||(LA37_3>=22 && LA37_3<=42)||(LA37_3>=62 && LA37_3<=64)||LA37_3==71||LA37_3==87||LA37_3==97||LA37_3==130) ) {
                    alt37=1;
                }
                else if ( (LA37_3==61) ) {
                    alt37=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 37, 3, input);

                    throw nvae;
                }
                }
                break;
            case 61:
                {
                alt37=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 37, 0, input);

                throw nvae;
            }

            switch (alt37) {
                case 1 :
                    // InternalQVTbase.g:4118:1: ( ruleExpCS )
                    {
                    // InternalQVTbase.g:4118:1: ( ruleExpCS )
                    // InternalQVTbase.g:4119:1: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_2_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4124:6: ( rulePatternExpCS )
                    {
                    // InternalQVTbase.g:4124:6: ( rulePatternExpCS )
                    // InternalQVTbase.g:4125:1: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePatternExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionPatternExpCSParserRuleCall_0_2_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0"


    // $ANTLR start "rule__PrimitiveLiteralExpCS__Alternatives"
    // InternalQVTbase.g:4135:1: rule__PrimitiveLiteralExpCS__Alternatives : ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) );
    public final void rule__PrimitiveLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4139:1: ( ( ruleNumberLiteralExpCS ) | ( ruleStringLiteralExpCS ) | ( ruleBooleanLiteralExpCS ) | ( ruleUnlimitedNaturalLiteralExpCS ) | ( ruleInvalidLiteralExpCS ) | ( ruleNullLiteralExpCS ) )
            int alt38=6;
            switch ( input.LA(1) ) {
            case RULE_INT:
                {
                alt38=1;
                }
                break;
            case RULE_SINGLE_QUOTED_STRING:
                {
                alt38=2;
                }
                break;
            case 128:
            case 129:
                {
                alt38=3;
                }
                break;
            case 22:
                {
                alt38=4;
                }
                break;
            case 84:
                {
                alt38=5;
                }
                break;
            case 85:
                {
                alt38=6;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 38, 0, input);

                throw nvae;
            }

            switch (alt38) {
                case 1 :
                    // InternalQVTbase.g:4140:1: ( ruleNumberLiteralExpCS )
                    {
                    // InternalQVTbase.g:4140:1: ( ruleNumberLiteralExpCS )
                    // InternalQVTbase.g:4141:1: ruleNumberLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNumberLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNumberLiteralExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4146:6: ( ruleStringLiteralExpCS )
                    {
                    // InternalQVTbase.g:4146:6: ( ruleStringLiteralExpCS )
                    // InternalQVTbase.g:4147:1: ruleStringLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleStringLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getStringLiteralExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4152:6: ( ruleBooleanLiteralExpCS )
                    {
                    // InternalQVTbase.g:4152:6: ( ruleBooleanLiteralExpCS )
                    // InternalQVTbase.g:4153:1: ruleBooleanLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleBooleanLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getBooleanLiteralExpCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:4158:6: ( ruleUnlimitedNaturalLiteralExpCS )
                    {
                    // InternalQVTbase.g:4158:6: ( ruleUnlimitedNaturalLiteralExpCS )
                    // InternalQVTbase.g:4159:1: ruleUnlimitedNaturalLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnlimitedNaturalLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSParserRuleCall_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:4164:6: ( ruleInvalidLiteralExpCS )
                    {
                    // InternalQVTbase.g:4164:6: ( ruleInvalidLiteralExpCS )
                    // InternalQVTbase.g:4165:1: ruleInvalidLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleInvalidLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getInvalidLiteralExpCSParserRuleCall_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:4170:6: ( ruleNullLiteralExpCS )
                    {
                    // InternalQVTbase.g:4170:6: ( ruleNullLiteralExpCS )
                    // InternalQVTbase.g:4171:1: ruleNullLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNullLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimitiveLiteralExpCSAccess().getNullLiteralExpCSParserRuleCall_5());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveLiteralExpCS__Alternatives"


    // $ANTLR start "rule__BooleanLiteralExpCS__Alternatives"
    // InternalQVTbase.g:4181:1: rule__BooleanLiteralExpCS__Alternatives : ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) );
    public final void rule__BooleanLiteralExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4185:1: ( ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) ) | ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) ) )
            int alt39=2;
            int LA39_0 = input.LA(1);

            if ( (LA39_0==128) ) {
                alt39=1;
            }
            else if ( (LA39_0==129) ) {
                alt39=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 39, 0, input);

                throw nvae;
            }
            switch (alt39) {
                case 1 :
                    // InternalQVTbase.g:4186:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    {
                    // InternalQVTbase.g:4186:1: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_0 ) )
                    // InternalQVTbase.g:4187:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0());
                    }
                    // InternalQVTbase.g:4188:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_0 )
                    // InternalQVTbase.g:4188:2: rule__BooleanLiteralExpCS__SymbolAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__BooleanLiteralExpCS__SymbolAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4192:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    {
                    // InternalQVTbase.g:4192:6: ( ( rule__BooleanLiteralExpCS__SymbolAssignment_1 ) )
                    // InternalQVTbase.g:4193:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1());
                    }
                    // InternalQVTbase.g:4194:1: ( rule__BooleanLiteralExpCS__SymbolAssignment_1 )
                    // InternalQVTbase.g:4194:2: rule__BooleanLiteralExpCS__SymbolAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__BooleanLiteralExpCS__SymbolAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolAssignment_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__Alternatives"


    // $ANTLR start "rule__TypeLiteralCS__Alternatives"
    // InternalQVTbase.g:4203:1: rule__TypeLiteralCS__Alternatives : ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) );
    public final void rule__TypeLiteralCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4207:1: ( ( rulePrimitiveTypeCS ) | ( ruleCollectionTypeCS ) | ( ruleMapTypeCS ) | ( ruleTupleTypeCS ) )
            int alt40=4;
            switch ( input.LA(1) ) {
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
                {
                alt40=1;
                }
                break;
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
                {
                alt40=2;
                }
                break;
            case 43:
                {
                alt40=3;
                }
                break;
            case 44:
                {
                alt40=4;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 40, 0, input);

                throw nvae;
            }

            switch (alt40) {
                case 1 :
                    // InternalQVTbase.g:4208:1: ( rulePrimitiveTypeCS )
                    {
                    // InternalQVTbase.g:4208:1: ( rulePrimitiveTypeCS )
                    // InternalQVTbase.g:4209:1: rulePrimitiveTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getPrimitiveTypeCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4214:6: ( ruleCollectionTypeCS )
                    {
                    // InternalQVTbase.g:4214:6: ( ruleCollectionTypeCS )
                    // InternalQVTbase.g:4215:1: ruleCollectionTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getCollectionTypeCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4220:6: ( ruleMapTypeCS )
                    {
                    // InternalQVTbase.g:4220:6: ( ruleMapTypeCS )
                    // InternalQVTbase.g:4221:1: ruleMapTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMapTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getMapTypeCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:4226:6: ( ruleTupleTypeCS )
                    {
                    // InternalQVTbase.g:4226:6: ( ruleTupleTypeCS )
                    // InternalQVTbase.g:4227:1: ruleTupleTypeCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTupleTypeCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeLiteralCSAccess().getTupleTypeCSParserRuleCall_3());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralCS__Alternatives"


    // $ANTLR start "rule__TypeExpWithoutMultiplicityCS__Alternatives"
    // InternalQVTbase.g:4237:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );
    public final void rule__TypeExpWithoutMultiplicityCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4241:1: ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) )
            int alt41=3;
            alt41 = dfa41.predict(input);
            switch (alt41) {
                case 1 :
                    // InternalQVTbase.g:4242:1: ( ruleTypeNameExpCS )
                    {
                    // InternalQVTbase.g:4242:1: ( ruleTypeNameExpCS )
                    // InternalQVTbase.g:4243:1: ruleTypeNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeNameExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeNameExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4248:6: ( ruleTypeLiteralCS )
                    {
                    // InternalQVTbase.g:4248:6: ( ruleTypeLiteralCS )
                    // InternalQVTbase.g:4249:1: ruleTypeLiteralCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeLiteralCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4254:6: ( ruleCollectionPatternCS )
                    {
                    // InternalQVTbase.g:4254:6: ( ruleCollectionPatternCS )
                    // InternalQVTbase.g:4255:1: ruleCollectionPatternCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionPatternCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getCollectionPatternCSParserRuleCall_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpWithoutMultiplicityCS__Alternatives"


    // $ANTLR start "rule__ExpCS__Alternatives"
    // InternalQVTbase.g:4265:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );
    public final void rule__ExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4269:1: ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) )
            int alt42=2;
            alt42 = dfa42.predict(input);
            switch (alt42) {
                case 1 :
                    // InternalQVTbase.g:4270:1: ( ( rule__ExpCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4270:1: ( ( rule__ExpCS__Group_0__0 ) )
                    // InternalQVTbase.g:4271:1: ( rule__ExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4272:1: ( rule__ExpCS__Group_0__0 )
                    // InternalQVTbase.g:4272:2: rule__ExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4276:6: ( rulePrefixedLetExpCS )
                    {
                    // InternalQVTbase.g:4276:6: ( rulePrefixedLetExpCS )
                    // InternalQVTbase.g:4277:1: rulePrefixedLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrefixedLetExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getExpCSAccess().getPrefixedLetExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Alternatives"


    // $ANTLR start "rule__PrefixedLetExpCS__Alternatives"
    // InternalQVTbase.g:4287:1: rule__PrefixedLetExpCS__Alternatives : ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) );
    public final void rule__PrefixedLetExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4291:1: ( ( ( rule__PrefixedLetExpCS__Group_0__0 ) ) | ( ruleLetExpCS ) )
            int alt43=2;
            int LA43_0 = input.LA(1);

            if ( ((LA43_0>=19 && LA43_0<=21)) ) {
                alt43=1;
            }
            else if ( (LA43_0==95) ) {
                alt43=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 43, 0, input);

                throw nvae;
            }
            switch (alt43) {
                case 1 :
                    // InternalQVTbase.g:4292:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4292:1: ( ( rule__PrefixedLetExpCS__Group_0__0 ) )
                    // InternalQVTbase.g:4293:1: ( rule__PrefixedLetExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4294:1: ( rule__PrefixedLetExpCS__Group_0__0 )
                    // InternalQVTbase.g:4294:2: rule__PrefixedLetExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PrefixedLetExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedLetExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4298:6: ( ruleLetExpCS )
                    {
                    // InternalQVTbase.g:4298:6: ( ruleLetExpCS )
                    // InternalQVTbase.g:4299:1: ruleLetExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleLetExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedLetExpCSAccess().getLetExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Alternatives"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Alternatives"
    // InternalQVTbase.g:4309:1: rule__PrefixedPrimaryExpCS__Alternatives : ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) );
    public final void rule__PrefixedPrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4313:1: ( ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) ) | ( rulePrimaryExpCS ) )
            int alt44=2;
            int LA44_0 = input.LA(1);

            if ( ((LA44_0>=19 && LA44_0<=21)) ) {
                alt44=1;
            }
            else if ( ((LA44_0>=RULE_INT && LA44_0<=RULE_ESCAPED_ID)||LA44_0==22||(LA44_0>=43 && LA44_0<=57)||LA44_0==71||LA44_0==82||(LA44_0>=84 && LA44_0<=85)||LA44_0==90||LA44_0==96||(LA44_0>=128 && LA44_0<=129)) ) {
                alt44=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 44, 0, input);

                throw nvae;
            }
            switch (alt44) {
                case 1 :
                    // InternalQVTbase.g:4314:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4314:1: ( ( rule__PrefixedPrimaryExpCS__Group_0__0 ) )
                    // InternalQVTbase.g:4315:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4316:1: ( rule__PrefixedPrimaryExpCS__Group_0__0 )
                    // InternalQVTbase.g:4316:2: rule__PrefixedPrimaryExpCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PrefixedPrimaryExpCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedPrimaryExpCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4320:6: ( rulePrimaryExpCS )
                    {
                    // InternalQVTbase.g:4320:6: ( rulePrimaryExpCS )
                    // InternalQVTbase.g:4321:1: rulePrimaryExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimaryExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrimaryExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Alternatives"


    // $ANTLR start "rule__PrimaryExpCS__Alternatives"
    // InternalQVTbase.g:4331:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) );
    public final void rule__PrimaryExpCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4335:1: ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) )
            int alt45=10;
            alt45 = dfa45.predict(input);
            switch (alt45) {
                case 1 :
                    // InternalQVTbase.g:4336:1: ( ruleNestedExpCS )
                    {
                    // InternalQVTbase.g:4336:1: ( ruleNestedExpCS )
                    // InternalQVTbase.g:4337:1: ruleNestedExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNestedExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getNestedExpCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4342:6: ( ruleIfExpCS )
                    {
                    // InternalQVTbase.g:4342:6: ( ruleIfExpCS )
                    // InternalQVTbase.g:4343:1: ruleIfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleIfExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getIfExpCSParserRuleCall_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4348:6: ( ruleSelfExpCS )
                    {
                    // InternalQVTbase.g:4348:6: ( ruleSelfExpCS )
                    // InternalQVTbase.g:4349:1: ruleSelfExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleSelfExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getSelfExpCSParserRuleCall_2());
                    }

                    }


                    }
                    break;
                case 4 :
                    // InternalQVTbase.g:4354:6: ( rulePrimitiveLiteralExpCS )
                    {
                    // InternalQVTbase.g:4354:6: ( rulePrimitiveLiteralExpCS )
                    // InternalQVTbase.g:4355:1: rulePrimitiveLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePrimitiveLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getPrimitiveLiteralExpCSParserRuleCall_3());
                    }

                    }


                    }
                    break;
                case 5 :
                    // InternalQVTbase.g:4360:6: ( ruleTupleLiteralExpCS )
                    {
                    // InternalQVTbase.g:4360:6: ( ruleTupleLiteralExpCS )
                    // InternalQVTbase.g:4361:1: ruleTupleLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTupleLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
                    }

                    }


                    }
                    break;
                case 6 :
                    // InternalQVTbase.g:4366:6: ( ruleMapLiteralExpCS )
                    {
                    // InternalQVTbase.g:4366:6: ( ruleMapLiteralExpCS )
                    // InternalQVTbase.g:4367:1: ruleMapLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMapLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
                    }

                    }


                    }
                    break;
                case 7 :
                    // InternalQVTbase.g:4372:6: ( ruleCollectionLiteralExpCS )
                    {
                    // InternalQVTbase.g:4372:6: ( ruleCollectionLiteralExpCS )
                    // InternalQVTbase.g:4373:1: ruleCollectionLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleCollectionLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
                    }

                    }


                    }
                    break;
                case 8 :
                    // InternalQVTbase.g:4378:6: ( ruleLambdaLiteralExpCS )
                    {
                    // InternalQVTbase.g:4378:6: ( ruleLambdaLiteralExpCS )
                    // InternalQVTbase.g:4379:1: ruleLambdaLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleLambdaLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getLambdaLiteralExpCSParserRuleCall_7());
                    }

                    }


                    }
                    break;
                case 9 :
                    // InternalQVTbase.g:4384:6: ( ruleTypeLiteralExpCS )
                    {
                    // InternalQVTbase.g:4384:6: ( ruleTypeLiteralExpCS )
                    // InternalQVTbase.g:4385:1: ruleTypeLiteralExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypeLiteralExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
                    }

                    }


                    }
                    break;
                case 10 :
                    // InternalQVTbase.g:4390:6: ( ruleNameExpCS )
                    {
                    // InternalQVTbase.g:4390:6: ( ruleNameExpCS )
                    // InternalQVTbase.g:4391:1: ruleNameExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNameExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getPrimaryExpCSAccess().getNameExpCSParserRuleCall_9());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimaryExpCS__Alternatives"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0"
    // InternalQVTbase.g:4401:1: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 : ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) );
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4405:1: ( ( ruleNavigatingCommaArgCS ) | ( ruleNavigatingSemiArgCS ) | ( ruleNavigatingBarArgCS ) )
            int alt46=3;
            switch ( input.LA(1) ) {
            case 64:
                {
                alt46=1;
                }
                break;
            case 17:
                {
                alt46=2;
                }
                break;
            case 131:
                {
                alt46=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 46, 0, input);

                throw nvae;
            }

            switch (alt46) {
                case 1 :
                    // InternalQVTbase.g:4406:1: ( ruleNavigatingCommaArgCS )
                    {
                    // InternalQVTbase.g:4406:1: ( ruleNavigatingCommaArgCS )
                    // InternalQVTbase.g:4407:1: ruleNavigatingCommaArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingCommaArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingCommaArgCSParserRuleCall_2_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4412:6: ( ruleNavigatingSemiArgCS )
                    {
                    // InternalQVTbase.g:4412:6: ( ruleNavigatingSemiArgCS )
                    // InternalQVTbase.g:4413:1: ruleNavigatingSemiArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingSemiArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingSemiArgCSParserRuleCall_2_1_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4418:6: ( ruleNavigatingBarArgCS )
                    {
                    // InternalQVTbase.g:4418:6: ( ruleNavigatingBarArgCS )
                    // InternalQVTbase.g:4419:1: ruleNavigatingBarArgCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleNavigatingBarArgCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingBarArgCSParserRuleCall_2_1_0_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives"
    // InternalQVTbase.g:4429:1: rule__NavigatingArgCS__Alternatives : ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) );
    public final void rule__NavigatingArgCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4433:1: ( ( ( rule__NavigatingArgCS__Group_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_1__0 ) ) )
            int alt47=2;
            int LA47_0 = input.LA(1);

            if ( ((LA47_0>=RULE_INT && LA47_0<=RULE_ESCAPED_ID)||(LA47_0>=19 && LA47_0<=22)||(LA47_0>=43 && LA47_0<=57)||LA47_0==71||LA47_0==82||(LA47_0>=84 && LA47_0<=85)||LA47_0==90||(LA47_0>=95 && LA47_0<=96)||(LA47_0>=128 && LA47_0<=129)) ) {
                alt47=1;
            }
            else if ( (LA47_0==61) ) {
                alt47=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 47, 0, input);

                throw nvae;
            }
            switch (alt47) {
                case 1 :
                    // InternalQVTbase.g:4434:1: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    {
                    // InternalQVTbase.g:4434:1: ( ( rule__NavigatingArgCS__Group_0__0 ) )
                    // InternalQVTbase.g:4435:1: ( rule__NavigatingArgCS__Group_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0());
                    }
                    // InternalQVTbase.g:4436:1: ( rule__NavigatingArgCS__Group_0__0 )
                    // InternalQVTbase.g:4436:2: rule__NavigatingArgCS__Group_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4440:6: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    {
                    // InternalQVTbase.g:4440:6: ( ( rule__NavigatingArgCS__Group_1__0 ) )
                    // InternalQVTbase.g:4441:1: ( rule__NavigatingArgCS__Group_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_1());
                    }
                    // InternalQVTbase.g:4442:1: ( rule__NavigatingArgCS__Group_1__0 )
                    // InternalQVTbase.g:4442:2: rule__NavigatingArgCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives"


    // $ANTLR start "rule__NavigatingArgCS__Alternatives_0_1"
    // InternalQVTbase.g:4451:1: rule__NavigatingArgCS__Alternatives_0_1 : ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) );
    public final void rule__NavigatingArgCS__Alternatives_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4455:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) | ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) ) )
            int alt48=3;
            switch ( input.LA(1) ) {
            case 83:
                {
                int LA48_1 = input.LA(2);

                if ( (synpred132_InternalQVTbase()) ) {
                    alt48=1;
                }
                else if ( (true) ) {
                    alt48=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 48, 1, input);

                    throw nvae;
                }
                }
                break;
            case 61:
                {
                int LA48_2 = input.LA(2);

                if ( (synpred133_InternalQVTbase()) ) {
                    alt48=2;
                }
                else if ( (true) ) {
                    alt48=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 48, 2, input);

                    throw nvae;
                }
                }
                break;
            case 89:
                {
                alt48=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 48, 0, input);

                throw nvae;
            }

            switch (alt48) {
                case 1 :
                    // InternalQVTbase.g:4456:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    {
                    // InternalQVTbase.g:4456:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
                    // InternalQVTbase.g:4457:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
                    }
                    // InternalQVTbase.g:4458:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
                    // InternalQVTbase.g:4458:2: rule__NavigatingArgCS__Group_0_1_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4462:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    {
                    // InternalQVTbase.g:4462:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
                    // InternalQVTbase.g:4463:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
                    }
                    // InternalQVTbase.g:4464:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
                    // InternalQVTbase.g:4464:2: rule__NavigatingArgCS__Group_0_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4468:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) )
                    {
                    // InternalQVTbase.g:4468:6: ( ( rule__NavigatingArgCS__Group_0_1_2__0 ) )
                    // InternalQVTbase.g:4469:1: ( rule__NavigatingArgCS__Group_0_1_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2());
                    }
                    // InternalQVTbase.g:4470:1: ( rule__NavigatingArgCS__Group_0_1_2__0 )
                    // InternalQVTbase.g:4470:2: rule__NavigatingArgCS__Group_0_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Alternatives_0_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Alternatives_2"
    // InternalQVTbase.g:4479:1: rule__NavigatingCommaArgCS__Alternatives_2 : ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) );
    public final void rule__NavigatingCommaArgCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4483:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) | ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) ) )
            int alt49=3;
            switch ( input.LA(1) ) {
            case 83:
                {
                int LA49_1 = input.LA(2);

                if ( (synpred134_InternalQVTbase()) ) {
                    alt49=1;
                }
                else if ( (true) ) {
                    alt49=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 49, 1, input);

                    throw nvae;
                }
                }
                break;
            case 61:
                {
                int LA49_2 = input.LA(2);

                if ( (synpred135_InternalQVTbase()) ) {
                    alt49=2;
                }
                else if ( (true) ) {
                    alt49=3;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 49, 2, input);

                    throw nvae;
                }
                }
                break;
            case 89:
                {
                alt49=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 49, 0, input);

                throw nvae;
            }

            switch (alt49) {
                case 1 :
                    // InternalQVTbase.g:4484:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    {
                    // InternalQVTbase.g:4484:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
                    // InternalQVTbase.g:4485:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
                    }
                    // InternalQVTbase.g:4486:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
                    // InternalQVTbase.g:4486:2: rule__NavigatingCommaArgCS__Group_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4490:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    {
                    // InternalQVTbase.g:4490:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
                    // InternalQVTbase.g:4491:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
                    }
                    // InternalQVTbase.g:4492:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
                    // InternalQVTbase.g:4492:2: rule__NavigatingCommaArgCS__Group_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4496:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) )
                    {
                    // InternalQVTbase.g:4496:6: ( ( rule__NavigatingCommaArgCS__Group_2_2__0 ) )
                    // InternalQVTbase.g:4497:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2());
                    }
                    // InternalQVTbase.g:4498:1: ( rule__NavigatingCommaArgCS__Group_2_2__0 )
                    // InternalQVTbase.g:4498:2: rule__NavigatingCommaArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Alternatives_2"


    // $ANTLR start "rule__IfExpCS__OwnedConditionAlternatives_1_0"
    // InternalQVTbase.g:4507:1: rule__IfExpCS__OwnedConditionAlternatives_1_0 : ( ( ruleExpCS ) | ( rulePatternExpCS ) );
    public final void rule__IfExpCS__OwnedConditionAlternatives_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4511:1: ( ( ruleExpCS ) | ( rulePatternExpCS ) )
            int alt50=2;
            switch ( input.LA(1) ) {
            case RULE_INT:
            case RULE_SINGLE_QUOTED_STRING:
            case 19:
            case 20:
            case 21:
            case 22:
            case 43:
            case 44:
            case 45:
            case 46:
            case 47:
            case 48:
            case 49:
            case 50:
            case 51:
            case 52:
            case 53:
            case 54:
            case 55:
            case 56:
            case 57:
            case 71:
            case 82:
            case 84:
            case 85:
            case 90:
            case 95:
            case 96:
            case 128:
            case 129:
                {
                alt50=1;
                }
                break;
            case RULE_SIMPLE_ID:
                {
                int LA50_2 = input.LA(2);

                if ( (LA50_2==19||(LA50_2>=22 && LA50_2<=42)||LA50_2==62||LA50_2==71||LA50_2==87||LA50_2==91||LA50_2==97||LA50_2==130) ) {
                    alt50=1;
                }
                else if ( (LA50_2==61) ) {
                    alt50=2;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 50, 2, input);

                    throw nvae;
                }
                }
                break;
            case RULE_ESCAPED_ID:
                {
                int LA50_3 = input.LA(2);

                if ( (LA50_3==61) ) {
                    alt50=2;
                }
                else if ( (LA50_3==19||(LA50_3>=22 && LA50_3<=42)||LA50_3==62||LA50_3==71||LA50_3==87||LA50_3==91||LA50_3==97||LA50_3==130) ) {
                    alt50=1;
                }
                else {
                    if (state.backtracking>0) {state.failed=true; return ;}
                    NoViableAltException nvae =
                        new NoViableAltException("", 50, 3, input);

                    throw nvae;
                }
                }
                break;
            case 61:
                {
                alt50=2;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 50, 0, input);

                throw nvae;
            }

            switch (alt50) {
                case 1 :
                    // InternalQVTbase.g:4512:1: ( ruleExpCS )
                    {
                    // InternalQVTbase.g:4512:1: ( ruleExpCS )
                    // InternalQVTbase.g:4513:1: ruleExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIfExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4518:6: ( rulePatternExpCS )
                    {
                    // InternalQVTbase.g:4518:6: ( rulePatternExpCS )
                    // InternalQVTbase.g:4519:1: rulePatternExpCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    rulePatternExpCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIfExpCSAccess().getOwnedConditionPatternExpCSParserRuleCall_1_0_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedConditionAlternatives_1_0"


    // $ANTLR start "rule__MultiplicityCS__Alternatives_1"
    // InternalQVTbase.g:4529:1: rule__MultiplicityCS__Alternatives_1 : ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) );
    public final void rule__MultiplicityCS__Alternatives_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4533:1: ( ( ruleMultiplicityBoundsCS ) | ( ruleMultiplicityStringCS ) )
            int alt51=2;
            int LA51_0 = input.LA(1);

            if ( (LA51_0==RULE_INT) ) {
                alt51=1;
            }
            else if ( (LA51_0==22||LA51_0==24||LA51_0==59) ) {
                alt51=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 51, 0, input);

                throw nvae;
            }
            switch (alt51) {
                case 1 :
                    // InternalQVTbase.g:4534:1: ( ruleMultiplicityBoundsCS )
                    {
                    // InternalQVTbase.g:4534:1: ( ruleMultiplicityBoundsCS )
                    // InternalQVTbase.g:4535:1: ruleMultiplicityBoundsCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMultiplicityBoundsCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getMultiplicityBoundsCSParserRuleCall_1_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4540:6: ( ruleMultiplicityStringCS )
                    {
                    // InternalQVTbase.g:4540:6: ( ruleMultiplicityStringCS )
                    // InternalQVTbase.g:4541:1: ruleMultiplicityStringCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleMultiplicityStringCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getMultiplicityStringCSParserRuleCall_1_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Alternatives_1"


    // $ANTLR start "rule__MultiplicityCS__Alternatives_2"
    // InternalQVTbase.g:4551:1: rule__MultiplicityCS__Alternatives_2 : ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) );
    public final void rule__MultiplicityCS__Alternatives_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4555:1: ( ( '|?' ) | ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) ) )
            int alt52=2;
            int LA52_0 = input.LA(1);

            if ( (LA52_0==58) ) {
                alt52=1;
            }
            else if ( (LA52_0==132) ) {
                alt52=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 52, 0, input);

                throw nvae;
            }
            switch (alt52) {
                case 1 :
                    // InternalQVTbase.g:4556:1: ( '|?' )
                    {
                    // InternalQVTbase.g:4556:1: ( '|?' )
                    // InternalQVTbase.g:4557:1: '|?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0());
                    }
                    match(input,58,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getVerticalLineQuestionMarkKeyword_2_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4564:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    {
                    // InternalQVTbase.g:4564:6: ( ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 ) )
                    // InternalQVTbase.g:4565:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1());
                    }
                    // InternalQVTbase.g:4566:1: ( rule__MultiplicityCS__IsNullFreeAssignment_2_1 )
                    // InternalQVTbase.g:4566:2: rule__MultiplicityCS__IsNullFreeAssignment_2_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityCS__IsNullFreeAssignment_2_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }

                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityCSAccess().getIsNullFreeAssignment_2_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Alternatives_2"


    // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAlternatives_0"
    // InternalQVTbase.g:4575:1: rule__MultiplicityStringCS__StringBoundsAlternatives_0 : ( ( '*' ) | ( '+' ) | ( '?' ) );
    public final void rule__MultiplicityStringCS__StringBoundsAlternatives_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4579:1: ( ( '*' ) | ( '+' ) | ( '?' ) )
            int alt53=3;
            switch ( input.LA(1) ) {
            case 22:
                {
                alt53=1;
                }
                break;
            case 24:
                {
                alt53=2;
                }
                break;
            case 59:
                {
                alt53=3;
                }
                break;
            default:
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 53, 0, input);

                throw nvae;
            }

            switch (alt53) {
                case 1 :
                    // InternalQVTbase.g:4580:1: ( '*' )
                    {
                    // InternalQVTbase.g:4580:1: ( '*' )
                    // InternalQVTbase.g:4581:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0());
                    }
                    match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAsteriskKeyword_0_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4588:6: ( '+' )
                    {
                    // InternalQVTbase.g:4588:6: ( '+' )
                    // InternalQVTbase.g:4589:1: '+'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1());
                    }
                    match(input,24,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsPlusSignKeyword_0_1());
                    }

                    }


                    }
                    break;
                case 3 :
                    // InternalQVTbase.g:4596:6: ( '?' )
                    {
                    // InternalQVTbase.g:4596:6: ( '?' )
                    // InternalQVTbase.g:4597:1: '?'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2());
                    }
                    match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsQuestionMarkKeyword_0_2());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAlternatives_0"


    // $ANTLR start "rule__TypeRefCS__Alternatives"
    // InternalQVTbase.g:4609:1: rule__TypeRefCS__Alternatives : ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) );
    public final void rule__TypeRefCS__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4613:1: ( ( ruleTypedRefCS ) | ( ruleWildcardTypeRefCS ) )
            int alt54=2;
            int LA54_0 = input.LA(1);

            if ( ((LA54_0>=RULE_SIMPLE_ID && LA54_0<=RULE_ESCAPED_ID)||(LA54_0>=43 && LA54_0<=57)) ) {
                alt54=1;
            }
            else if ( (LA54_0==59) ) {
                alt54=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 54, 0, input);

                throw nvae;
            }
            switch (alt54) {
                case 1 :
                    // InternalQVTbase.g:4614:1: ( ruleTypedRefCS )
                    {
                    // InternalQVTbase.g:4614:1: ( ruleTypedRefCS )
                    // InternalQVTbase.g:4615:1: ruleTypedRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleTypedRefCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeRefCSAccess().getTypedRefCSParserRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4620:6: ( ruleWildcardTypeRefCS )
                    {
                    // InternalQVTbase.g:4620:6: ( ruleWildcardTypeRefCS )
                    // InternalQVTbase.g:4621:1: ruleWildcardTypeRefCS
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1());
                    }
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleWildcardTypeRefCS();

                    state._fsp--;
                    if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getTypeRefCSAccess().getWildcardTypeRefCSParserRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeRefCS__Alternatives"


    // $ANTLR start "rule__ID__Alternatives"
    // InternalQVTbase.g:4631:1: rule__ID__Alternatives : ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) );
    public final void rule__ID__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4635:1: ( ( RULE_SIMPLE_ID ) | ( RULE_ESCAPED_ID ) )
            int alt55=2;
            int LA55_0 = input.LA(1);

            if ( (LA55_0==RULE_SIMPLE_ID) ) {
                alt55=1;
            }
            else if ( (LA55_0==RULE_ESCAPED_ID) ) {
                alt55=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 55, 0, input);

                throw nvae;
            }
            switch (alt55) {
                case 1 :
                    // InternalQVTbase.g:4636:1: ( RULE_SIMPLE_ID )
                    {
                    // InternalQVTbase.g:4636:1: ( RULE_SIMPLE_ID )
                    // InternalQVTbase.g:4637:1: RULE_SIMPLE_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0());
                    }
                    match(input,RULE_SIMPLE_ID,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIDAccess().getSIMPLE_IDTerminalRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4642:6: ( RULE_ESCAPED_ID )
                    {
                    // InternalQVTbase.g:4642:6: ( RULE_ESCAPED_ID )
                    // InternalQVTbase.g:4643:1: RULE_ESCAPED_ID
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1());
                    }
                    match(input,RULE_ESCAPED_ID,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getIDAccess().getESCAPED_IDTerminalRuleCall_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ID__Alternatives"


    // $ANTLR start "rule__UPPER__Alternatives"
    // InternalQVTbase.g:4653:1: rule__UPPER__Alternatives : ( ( RULE_INT ) | ( '*' ) );
    public final void rule__UPPER__Alternatives() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4657:1: ( ( RULE_INT ) | ( '*' ) )
            int alt56=2;
            int LA56_0 = input.LA(1);

            if ( (LA56_0==RULE_INT) ) {
                alt56=1;
            }
            else if ( (LA56_0==22) ) {
                alt56=2;
            }
            else {
                if (state.backtracking>0) {state.failed=true; return ;}
                NoViableAltException nvae =
                    new NoViableAltException("", 56, 0, input);

                throw nvae;
            }
            switch (alt56) {
                case 1 :
                    // InternalQVTbase.g:4658:1: ( RULE_INT )
                    {
                    // InternalQVTbase.g:4658:1: ( RULE_INT )
                    // InternalQVTbase.g:4659:1: RULE_INT
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0());
                    }
                    match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getUPPERAccess().getINTTerminalRuleCall_0());
                    }

                    }


                    }
                    break;
                case 2 :
                    // InternalQVTbase.g:4664:6: ( '*' )
                    {
                    // InternalQVTbase.g:4664:6: ( '*' )
                    // InternalQVTbase.g:4665:1: '*'
                    {
                    if ( state.backtracking==0 ) {
                       before(grammarAccess.getUPPERAccess().getAsteriskKeyword_1());
                    }
                    match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ;
                    if ( state.backtracking==0 ) {
                       after(grammarAccess.getUPPERAccess().getAsteriskKeyword_1());
                    }

                    }


                    }
                    break;

            }
        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UPPER__Alternatives"


    // $ANTLR start "rule__AttributeCS__Group__0"
    // InternalQVTbase.g:4679:1: rule__AttributeCS__Group__0 : rule__AttributeCS__Group__0__Impl rule__AttributeCS__Group__1 ;
    public final void rule__AttributeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4683:1: ( rule__AttributeCS__Group__0__Impl rule__AttributeCS__Group__1 )
            // InternalQVTbase.g:4684:2: rule__AttributeCS__Group__0__Impl rule__AttributeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_4);
            rule__AttributeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__0"


    // $ANTLR start "rule__AttributeCS__Group__0__Impl"
    // InternalQVTbase.g:4691:1: rule__AttributeCS__Group__0__Impl : ( ( rule__AttributeCS__Alternatives_0 )? ) ;
    public final void rule__AttributeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4695:1: ( ( ( rule__AttributeCS__Alternatives_0 )? ) )
            // InternalQVTbase.g:4696:1: ( ( rule__AttributeCS__Alternatives_0 )? )
            {
            // InternalQVTbase.g:4696:1: ( ( rule__AttributeCS__Alternatives_0 )? )
            // InternalQVTbase.g:4697:1: ( rule__AttributeCS__Alternatives_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getAlternatives_0());
            }
            // InternalQVTbase.g:4698:1: ( rule__AttributeCS__Alternatives_0 )?
            int alt57=2;
            int LA57_0 = input.LA(1);

            if ( ((LA57_0>=99 && LA57_0<=100)) ) {
                alt57=1;
            }
            switch (alt57) {
                case 1 :
                    // InternalQVTbase.g:4698:2: rule__AttributeCS__Alternatives_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Alternatives_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group__1"
    // InternalQVTbase.g:4708:1: rule__AttributeCS__Group__1 : rule__AttributeCS__Group__1__Impl rule__AttributeCS__Group__2 ;
    public final void rule__AttributeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4712:1: ( rule__AttributeCS__Group__1__Impl rule__AttributeCS__Group__2 )
            // InternalQVTbase.g:4713:2: rule__AttributeCS__Group__1__Impl rule__AttributeCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__AttributeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__1"


    // $ANTLR start "rule__AttributeCS__Group__1__Impl"
    // InternalQVTbase.g:4720:1: rule__AttributeCS__Group__1__Impl : ( 'attribute' ) ;
    public final void rule__AttributeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4724:1: ( ( 'attribute' ) )
            // InternalQVTbase.g:4725:1: ( 'attribute' )
            {
            // InternalQVTbase.g:4725:1: ( 'attribute' )
            // InternalQVTbase.g:4726:1: 'attribute'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getAttributeKeyword_1());
            }
            match(input,60,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getAttributeKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group__2"
    // InternalQVTbase.g:4739:1: rule__AttributeCS__Group__2 : rule__AttributeCS__Group__2__Impl rule__AttributeCS__Group__3 ;
    public final void rule__AttributeCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4743:1: ( rule__AttributeCS__Group__2__Impl rule__AttributeCS__Group__3 )
            // InternalQVTbase.g:4744:2: rule__AttributeCS__Group__2__Impl rule__AttributeCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__AttributeCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__2"


    // $ANTLR start "rule__AttributeCS__Group__2__Impl"
    // InternalQVTbase.g:4751:1: rule__AttributeCS__Group__2__Impl : ( ( rule__AttributeCS__NameAssignment_2 ) ) ;
    public final void rule__AttributeCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4755:1: ( ( ( rule__AttributeCS__NameAssignment_2 ) ) )
            // InternalQVTbase.g:4756:1: ( ( rule__AttributeCS__NameAssignment_2 ) )
            {
            // InternalQVTbase.g:4756:1: ( ( rule__AttributeCS__NameAssignment_2 ) )
            // InternalQVTbase.g:4757:1: ( rule__AttributeCS__NameAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getNameAssignment_2());
            }
            // InternalQVTbase.g:4758:1: ( rule__AttributeCS__NameAssignment_2 )
            // InternalQVTbase.g:4758:2: rule__AttributeCS__NameAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__NameAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getNameAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__2__Impl"


    // $ANTLR start "rule__AttributeCS__Group__3"
    // InternalQVTbase.g:4768:1: rule__AttributeCS__Group__3 : rule__AttributeCS__Group__3__Impl rule__AttributeCS__Group__4 ;
    public final void rule__AttributeCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4772:1: ( rule__AttributeCS__Group__3__Impl rule__AttributeCS__Group__4 )
            // InternalQVTbase.g:4773:2: rule__AttributeCS__Group__3__Impl rule__AttributeCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__AttributeCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__3"


    // $ANTLR start "rule__AttributeCS__Group__3__Impl"
    // InternalQVTbase.g:4780:1: rule__AttributeCS__Group__3__Impl : ( ( rule__AttributeCS__Group_3__0 )? ) ;
    public final void rule__AttributeCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4784:1: ( ( ( rule__AttributeCS__Group_3__0 )? ) )
            // InternalQVTbase.g:4785:1: ( ( rule__AttributeCS__Group_3__0 )? )
            {
            // InternalQVTbase.g:4785:1: ( ( rule__AttributeCS__Group_3__0 )? )
            // InternalQVTbase.g:4786:1: ( rule__AttributeCS__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup_3());
            }
            // InternalQVTbase.g:4787:1: ( rule__AttributeCS__Group_3__0 )?
            int alt58=2;
            int LA58_0 = input.LA(1);

            if ( (LA58_0==61) ) {
                alt58=1;
            }
            switch (alt58) {
                case 1 :
                    // InternalQVTbase.g:4787:2: rule__AttributeCS__Group_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__3__Impl"


    // $ANTLR start "rule__AttributeCS__Group__4"
    // InternalQVTbase.g:4797:1: rule__AttributeCS__Group__4 : rule__AttributeCS__Group__4__Impl rule__AttributeCS__Group__5 ;
    public final void rule__AttributeCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4801:1: ( rule__AttributeCS__Group__4__Impl rule__AttributeCS__Group__5 )
            // InternalQVTbase.g:4802:2: rule__AttributeCS__Group__4__Impl rule__AttributeCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__AttributeCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__4"


    // $ANTLR start "rule__AttributeCS__Group__4__Impl"
    // InternalQVTbase.g:4809:1: rule__AttributeCS__Group__4__Impl : ( ( rule__AttributeCS__Group_4__0 )? ) ;
    public final void rule__AttributeCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4813:1: ( ( ( rule__AttributeCS__Group_4__0 )? ) )
            // InternalQVTbase.g:4814:1: ( ( rule__AttributeCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:4814:1: ( ( rule__AttributeCS__Group_4__0 )? )
            // InternalQVTbase.g:4815:1: ( rule__AttributeCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:4816:1: ( rule__AttributeCS__Group_4__0 )?
            int alt59=2;
            int LA59_0 = input.LA(1);

            if ( (LA59_0==29) ) {
                alt59=1;
            }
            switch (alt59) {
                case 1 :
                    // InternalQVTbase.g:4816:2: rule__AttributeCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__4__Impl"


    // $ANTLR start "rule__AttributeCS__Group__5"
    // InternalQVTbase.g:4826:1: rule__AttributeCS__Group__5 : rule__AttributeCS__Group__5__Impl rule__AttributeCS__Group__6 ;
    public final void rule__AttributeCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4830:1: ( rule__AttributeCS__Group__5__Impl rule__AttributeCS__Group__6 )
            // InternalQVTbase.g:4831:2: rule__AttributeCS__Group__5__Impl rule__AttributeCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_6);
            rule__AttributeCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__5"


    // $ANTLR start "rule__AttributeCS__Group__5__Impl"
    // InternalQVTbase.g:4838:1: rule__AttributeCS__Group__5__Impl : ( ( rule__AttributeCS__Group_5__0 )? ) ;
    public final void rule__AttributeCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4842:1: ( ( ( rule__AttributeCS__Group_5__0 )? ) )
            // InternalQVTbase.g:4843:1: ( ( rule__AttributeCS__Group_5__0 )? )
            {
            // InternalQVTbase.g:4843:1: ( ( rule__AttributeCS__Group_5__0 )? )
            // InternalQVTbase.g:4844:1: ( rule__AttributeCS__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup_5());
            }
            // InternalQVTbase.g:4845:1: ( rule__AttributeCS__Group_5__0 )?
            int alt60=2;
            int LA60_0 = input.LA(1);

            if ( (LA60_0==62) ) {
                int LA60_1 = input.LA(2);

                if ( ((LA60_1>=101 && LA60_1<=116)) ) {
                    alt60=1;
                }
            }
            switch (alt60) {
                case 1 :
                    // InternalQVTbase.g:4845:2: rule__AttributeCS__Group_5__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getGroup_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__5__Impl"


    // $ANTLR start "rule__AttributeCS__Group__6"
    // InternalQVTbase.g:4855:1: rule__AttributeCS__Group__6 : rule__AttributeCS__Group__6__Impl ;
    public final void rule__AttributeCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4859:1: ( rule__AttributeCS__Group__6__Impl )
            // InternalQVTbase.g:4860:2: rule__AttributeCS__Group__6__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__6"


    // $ANTLR start "rule__AttributeCS__Group__6__Impl"
    // InternalQVTbase.g:4866:1: rule__AttributeCS__Group__6__Impl : ( ( rule__AttributeCS__Alternatives_6 ) ) ;
    public final void rule__AttributeCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4870:1: ( ( ( rule__AttributeCS__Alternatives_6 ) ) )
            // InternalQVTbase.g:4871:1: ( ( rule__AttributeCS__Alternatives_6 ) )
            {
            // InternalQVTbase.g:4871:1: ( ( rule__AttributeCS__Alternatives_6 ) )
            // InternalQVTbase.g:4872:1: ( rule__AttributeCS__Alternatives_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getAlternatives_6());
            }
            // InternalQVTbase.g:4873:1: ( rule__AttributeCS__Alternatives_6 )
            // InternalQVTbase.g:4873:2: rule__AttributeCS__Alternatives_6
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Alternatives_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getAlternatives_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group__6__Impl"


    // $ANTLR start "rule__AttributeCS__Group_0_0__0"
    // InternalQVTbase.g:4897:1: rule__AttributeCS__Group_0_0__0 : rule__AttributeCS__Group_0_0__0__Impl rule__AttributeCS__Group_0_0__1 ;
    public final void rule__AttributeCS__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4901:1: ( rule__AttributeCS__Group_0_0__0__Impl rule__AttributeCS__Group_0_0__1 )
            // InternalQVTbase.g:4902:2: rule__AttributeCS__Group_0_0__0__Impl rule__AttributeCS__Group_0_0__1
            {
            pushFollow(FollowSets000.FOLLOW_7);
            rule__AttributeCS__Group_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_0_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_0__0"


    // $ANTLR start "rule__AttributeCS__Group_0_0__0__Impl"
    // InternalQVTbase.g:4909:1: rule__AttributeCS__Group_0_0__0__Impl : ( ( rule__AttributeCS__QualifiersAssignment_0_0_0 ) ) ;
    public final void rule__AttributeCS__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4913:1: ( ( ( rule__AttributeCS__QualifiersAssignment_0_0_0 ) ) )
            // InternalQVTbase.g:4914:1: ( ( rule__AttributeCS__QualifiersAssignment_0_0_0 ) )
            {
            // InternalQVTbase.g:4914:1: ( ( rule__AttributeCS__QualifiersAssignment_0_0_0 ) )
            // InternalQVTbase.g:4915:1: ( rule__AttributeCS__QualifiersAssignment_0_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_0_0());
            }
            // InternalQVTbase.g:4916:1: ( rule__AttributeCS__QualifiersAssignment_0_0_0 )
            // InternalQVTbase.g:4916:2: rule__AttributeCS__QualifiersAssignment_0_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__QualifiersAssignment_0_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_0__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_0_0__1"
    // InternalQVTbase.g:4926:1: rule__AttributeCS__Group_0_0__1 : rule__AttributeCS__Group_0_0__1__Impl ;
    public final void rule__AttributeCS__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4930:1: ( rule__AttributeCS__Group_0_0__1__Impl )
            // InternalQVTbase.g:4931:2: rule__AttributeCS__Group_0_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_0_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_0__1"


    // $ANTLR start "rule__AttributeCS__Group_0_0__1__Impl"
    // InternalQVTbase.g:4937:1: rule__AttributeCS__Group_0_0__1__Impl : ( ( rule__AttributeCS__QualifiersAssignment_0_0_1 )? ) ;
    public final void rule__AttributeCS__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4941:1: ( ( ( rule__AttributeCS__QualifiersAssignment_0_0_1 )? ) )
            // InternalQVTbase.g:4942:1: ( ( rule__AttributeCS__QualifiersAssignment_0_0_1 )? )
            {
            // InternalQVTbase.g:4942:1: ( ( rule__AttributeCS__QualifiersAssignment_0_0_1 )? )
            // InternalQVTbase.g:4943:1: ( rule__AttributeCS__QualifiersAssignment_0_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_0_1());
            }
            // InternalQVTbase.g:4944:1: ( rule__AttributeCS__QualifiersAssignment_0_0_1 )?
            int alt61=2;
            int LA61_0 = input.LA(1);

            if ( (LA61_0==100) ) {
                alt61=1;
            }
            switch (alt61) {
                case 1 :
                    // InternalQVTbase.g:4944:2: rule__AttributeCS__QualifiersAssignment_0_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_0_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_0__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_0_1__0"
    // InternalQVTbase.g:4958:1: rule__AttributeCS__Group_0_1__0 : rule__AttributeCS__Group_0_1__0__Impl rule__AttributeCS__Group_0_1__1 ;
    public final void rule__AttributeCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4962:1: ( rule__AttributeCS__Group_0_1__0__Impl rule__AttributeCS__Group_0_1__1 )
            // InternalQVTbase.g:4963:2: rule__AttributeCS__Group_0_1__0__Impl rule__AttributeCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__AttributeCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_1__0"


    // $ANTLR start "rule__AttributeCS__Group_0_1__0__Impl"
    // InternalQVTbase.g:4970:1: rule__AttributeCS__Group_0_1__0__Impl : ( ( rule__AttributeCS__QualifiersAssignment_0_1_0 ) ) ;
    public final void rule__AttributeCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4974:1: ( ( ( rule__AttributeCS__QualifiersAssignment_0_1_0 ) ) )
            // InternalQVTbase.g:4975:1: ( ( rule__AttributeCS__QualifiersAssignment_0_1_0 ) )
            {
            // InternalQVTbase.g:4975:1: ( ( rule__AttributeCS__QualifiersAssignment_0_1_0 ) )
            // InternalQVTbase.g:4976:1: ( rule__AttributeCS__QualifiersAssignment_0_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_1_0());
            }
            // InternalQVTbase.g:4977:1: ( rule__AttributeCS__QualifiersAssignment_0_1_0 )
            // InternalQVTbase.g:4977:2: rule__AttributeCS__QualifiersAssignment_0_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__QualifiersAssignment_0_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_0_1__1"
    // InternalQVTbase.g:4987:1: rule__AttributeCS__Group_0_1__1 : rule__AttributeCS__Group_0_1__1__Impl ;
    public final void rule__AttributeCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:4991:1: ( rule__AttributeCS__Group_0_1__1__Impl )
            // InternalQVTbase.g:4992:2: rule__AttributeCS__Group_0_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_1__1"


    // $ANTLR start "rule__AttributeCS__Group_0_1__1__Impl"
    // InternalQVTbase.g:4998:1: rule__AttributeCS__Group_0_1__1__Impl : ( ( rule__AttributeCS__QualifiersAssignment_0_1_1 )? ) ;
    public final void rule__AttributeCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5002:1: ( ( ( rule__AttributeCS__QualifiersAssignment_0_1_1 )? ) )
            // InternalQVTbase.g:5003:1: ( ( rule__AttributeCS__QualifiersAssignment_0_1_1 )? )
            {
            // InternalQVTbase.g:5003:1: ( ( rule__AttributeCS__QualifiersAssignment_0_1_1 )? )
            // InternalQVTbase.g:5004:1: ( rule__AttributeCS__QualifiersAssignment_0_1_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_1_1());
            }
            // InternalQVTbase.g:5005:1: ( rule__AttributeCS__QualifiersAssignment_0_1_1 )?
            int alt62=2;
            int LA62_0 = input.LA(1);

            if ( (LA62_0==99) ) {
                alt62=1;
            }
            switch (alt62) {
                case 1 :
                    // InternalQVTbase.g:5005:2: rule__AttributeCS__QualifiersAssignment_0_1_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__QualifiersAssignment_0_1_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_3__0"
    // InternalQVTbase.g:5019:1: rule__AttributeCS__Group_3__0 : rule__AttributeCS__Group_3__0__Impl rule__AttributeCS__Group_3__1 ;
    public final void rule__AttributeCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5023:1: ( rule__AttributeCS__Group_3__0__Impl rule__AttributeCS__Group_3__1 )
            // InternalQVTbase.g:5024:2: rule__AttributeCS__Group_3__0__Impl rule__AttributeCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__AttributeCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_3__0"


    // $ANTLR start "rule__AttributeCS__Group_3__0__Impl"
    // InternalQVTbase.g:5031:1: rule__AttributeCS__Group_3__0__Impl : ( ':' ) ;
    public final void rule__AttributeCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5035:1: ( ( ':' ) )
            // InternalQVTbase.g:5036:1: ( ':' )
            {
            // InternalQVTbase.g:5036:1: ( ':' )
            // InternalQVTbase.g:5037:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getColonKeyword_3_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getColonKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_3__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_3__1"
    // InternalQVTbase.g:5050:1: rule__AttributeCS__Group_3__1 : rule__AttributeCS__Group_3__1__Impl ;
    public final void rule__AttributeCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5054:1: ( rule__AttributeCS__Group_3__1__Impl )
            // InternalQVTbase.g:5055:2: rule__AttributeCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__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__AttributeCS__Group_3__1"


    // $ANTLR start "rule__AttributeCS__Group_3__1__Impl"
    // InternalQVTbase.g:5061:1: rule__AttributeCS__Group_3__1__Impl : ( ( rule__AttributeCS__OwnedTypeAssignment_3_1 ) ) ;
    public final void rule__AttributeCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5065:1: ( ( ( rule__AttributeCS__OwnedTypeAssignment_3_1 ) ) )
            // InternalQVTbase.g:5066:1: ( ( rule__AttributeCS__OwnedTypeAssignment_3_1 ) )
            {
            // InternalQVTbase.g:5066:1: ( ( rule__AttributeCS__OwnedTypeAssignment_3_1 ) )
            // InternalQVTbase.g:5067:1: ( rule__AttributeCS__OwnedTypeAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedTypeAssignment_3_1());
            }
            // InternalQVTbase.g:5068:1: ( rule__AttributeCS__OwnedTypeAssignment_3_1 )
            // InternalQVTbase.g:5068:2: rule__AttributeCS__OwnedTypeAssignment_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__OwnedTypeAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedTypeAssignment_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_3__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_4__0"
    // InternalQVTbase.g:5082:1: rule__AttributeCS__Group_4__0 : rule__AttributeCS__Group_4__0__Impl rule__AttributeCS__Group_4__1 ;
    public final void rule__AttributeCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5086:1: ( rule__AttributeCS__Group_4__0__Impl rule__AttributeCS__Group_4__1 )
            // InternalQVTbase.g:5087:2: rule__AttributeCS__Group_4__0__Impl rule__AttributeCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__AttributeCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_4__0"


    // $ANTLR start "rule__AttributeCS__Group_4__0__Impl"
    // InternalQVTbase.g:5094:1: rule__AttributeCS__Group_4__0__Impl : ( '=' ) ;
    public final void rule__AttributeCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5098:1: ( ( '=' ) )
            // InternalQVTbase.g:5099:1: ( '=' )
            {
            // InternalQVTbase.g:5099:1: ( '=' )
            // InternalQVTbase.g:5100:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getEqualsSignKeyword_4_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getEqualsSignKeyword_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_4__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_4__1"
    // InternalQVTbase.g:5113:1: rule__AttributeCS__Group_4__1 : rule__AttributeCS__Group_4__1__Impl ;
    public final void rule__AttributeCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5117:1: ( rule__AttributeCS__Group_4__1__Impl )
            // InternalQVTbase.g:5118:2: rule__AttributeCS__Group_4__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_4__1"


    // $ANTLR start "rule__AttributeCS__Group_4__1__Impl"
    // InternalQVTbase.g:5124:1: rule__AttributeCS__Group_4__1__Impl : ( ( rule__AttributeCS__DefaultAssignment_4_1 ) ) ;
    public final void rule__AttributeCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5128:1: ( ( ( rule__AttributeCS__DefaultAssignment_4_1 ) ) )
            // InternalQVTbase.g:5129:1: ( ( rule__AttributeCS__DefaultAssignment_4_1 ) )
            {
            // InternalQVTbase.g:5129:1: ( ( rule__AttributeCS__DefaultAssignment_4_1 ) )
            // InternalQVTbase.g:5130:1: ( rule__AttributeCS__DefaultAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getDefaultAssignment_4_1());
            }
            // InternalQVTbase.g:5131:1: ( rule__AttributeCS__DefaultAssignment_4_1 )
            // InternalQVTbase.g:5131:2: rule__AttributeCS__DefaultAssignment_4_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__DefaultAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getDefaultAssignment_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_4__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_5__0"
    // InternalQVTbase.g:5145:1: rule__AttributeCS__Group_5__0 : rule__AttributeCS__Group_5__0__Impl rule__AttributeCS__Group_5__1 ;
    public final void rule__AttributeCS__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5149:1: ( rule__AttributeCS__Group_5__0__Impl rule__AttributeCS__Group_5__1 )
            // InternalQVTbase.g:5150:2: rule__AttributeCS__Group_5__0__Impl rule__AttributeCS__Group_5__1
            {
            pushFollow(FollowSets000.FOLLOW_11);
            rule__AttributeCS__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__0"


    // $ANTLR start "rule__AttributeCS__Group_5__0__Impl"
    // InternalQVTbase.g:5157:1: rule__AttributeCS__Group_5__0__Impl : ( '{' ) ;
    public final void rule__AttributeCS__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5161:1: ( ( '{' ) )
            // InternalQVTbase.g:5162:1: ( '{' )
            {
            // InternalQVTbase.g:5162:1: ( '{' )
            // InternalQVTbase.g:5163:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getLeftCurlyBracketKeyword_5_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getLeftCurlyBracketKeyword_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_5__1"
    // InternalQVTbase.g:5176:1: rule__AttributeCS__Group_5__1 : rule__AttributeCS__Group_5__1__Impl rule__AttributeCS__Group_5__2 ;
    public final void rule__AttributeCS__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5180:1: ( rule__AttributeCS__Group_5__1__Impl rule__AttributeCS__Group_5__2 )
            // InternalQVTbase.g:5181:2: rule__AttributeCS__Group_5__1__Impl rule__AttributeCS__Group_5__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__AttributeCS__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_5__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__1"


    // $ANTLR start "rule__AttributeCS__Group_5__1__Impl"
    // InternalQVTbase.g:5188:1: rule__AttributeCS__Group_5__1__Impl : ( ( ( rule__AttributeCS__Group_5_1__0 ) ) ( ( rule__AttributeCS__Group_5_1__0 )* ) ) ;
    public final void rule__AttributeCS__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5192:1: ( ( ( ( rule__AttributeCS__Group_5_1__0 ) ) ( ( rule__AttributeCS__Group_5_1__0 )* ) ) )
            // InternalQVTbase.g:5193:1: ( ( ( rule__AttributeCS__Group_5_1__0 ) ) ( ( rule__AttributeCS__Group_5_1__0 )* ) )
            {
            // InternalQVTbase.g:5193:1: ( ( ( rule__AttributeCS__Group_5_1__0 ) ) ( ( rule__AttributeCS__Group_5_1__0 )* ) )
            // InternalQVTbase.g:5194:1: ( ( rule__AttributeCS__Group_5_1__0 ) ) ( ( rule__AttributeCS__Group_5_1__0 )* )
            {
            // InternalQVTbase.g:5194:1: ( ( rule__AttributeCS__Group_5_1__0 ) )
            // InternalQVTbase.g:5195:1: ( rule__AttributeCS__Group_5_1__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup_5_1());
            }
            // InternalQVTbase.g:5196:1: ( rule__AttributeCS__Group_5_1__0 )
            // InternalQVTbase.g:5196:2: rule__AttributeCS__Group_5_1__0
            {
            pushFollow(FollowSets000.FOLLOW_13);
            rule__AttributeCS__Group_5_1__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getGroup_5_1());
            }

            }

            // InternalQVTbase.g:5199:1: ( ( rule__AttributeCS__Group_5_1__0 )* )
            // InternalQVTbase.g:5200:1: ( rule__AttributeCS__Group_5_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getGroup_5_1());
            }
            // InternalQVTbase.g:5201:1: ( rule__AttributeCS__Group_5_1__0 )*
            loop63:
            do {
                int alt63=2;
                int LA63_0 = input.LA(1);

                if ( ((LA63_0>=101 && LA63_0<=116)) ) {
                    alt63=1;
                }


                switch (alt63) {
            	case 1 :
            	    // InternalQVTbase.g:5201:2: rule__AttributeCS__Group_5_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_13);
            	    rule__AttributeCS__Group_5_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop63;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getGroup_5_1());
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_5__2"
    // InternalQVTbase.g:5212:1: rule__AttributeCS__Group_5__2 : rule__AttributeCS__Group_5__2__Impl ;
    public final void rule__AttributeCS__Group_5__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5216:1: ( rule__AttributeCS__Group_5__2__Impl )
            // InternalQVTbase.g:5217:2: rule__AttributeCS__Group_5__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_5__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__2"


    // $ANTLR start "rule__AttributeCS__Group_5__2__Impl"
    // InternalQVTbase.g:5223:1: rule__AttributeCS__Group_5__2__Impl : ( '}' ) ;
    public final void rule__AttributeCS__Group_5__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5227:1: ( ( '}' ) )
            // InternalQVTbase.g:5228:1: ( '}' )
            {
            // InternalQVTbase.g:5228:1: ( '}' )
            // InternalQVTbase.g:5229:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getRightCurlyBracketKeyword_5_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getRightCurlyBracketKeyword_5_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5__2__Impl"


    // $ANTLR start "rule__AttributeCS__Group_5_1__0"
    // InternalQVTbase.g:5248:1: rule__AttributeCS__Group_5_1__0 : rule__AttributeCS__Group_5_1__0__Impl rule__AttributeCS__Group_5_1__1 ;
    public final void rule__AttributeCS__Group_5_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5252:1: ( rule__AttributeCS__Group_5_1__0__Impl rule__AttributeCS__Group_5_1__1 )
            // InternalQVTbase.g:5253:2: rule__AttributeCS__Group_5_1__0__Impl rule__AttributeCS__Group_5_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__AttributeCS__Group_5_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_5_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5_1__0"


    // $ANTLR start "rule__AttributeCS__Group_5_1__0__Impl"
    // InternalQVTbase.g:5260:1: rule__AttributeCS__Group_5_1__0__Impl : ( ( rule__AttributeCS__Alternatives_5_1_0 ) ) ;
    public final void rule__AttributeCS__Group_5_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5264:1: ( ( ( rule__AttributeCS__Alternatives_5_1_0 ) ) )
            // InternalQVTbase.g:5265:1: ( ( rule__AttributeCS__Alternatives_5_1_0 ) )
            {
            // InternalQVTbase.g:5265:1: ( ( rule__AttributeCS__Alternatives_5_1_0 ) )
            // InternalQVTbase.g:5266:1: ( rule__AttributeCS__Alternatives_5_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getAlternatives_5_1_0());
            }
            // InternalQVTbase.g:5267:1: ( rule__AttributeCS__Alternatives_5_1_0 )
            // InternalQVTbase.g:5267:2: rule__AttributeCS__Alternatives_5_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Alternatives_5_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getAlternatives_5_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5_1__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_5_1__1"
    // InternalQVTbase.g:5277:1: rule__AttributeCS__Group_5_1__1 : rule__AttributeCS__Group_5_1__1__Impl ;
    public final void rule__AttributeCS__Group_5_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5281:1: ( rule__AttributeCS__Group_5_1__1__Impl )
            // InternalQVTbase.g:5282:2: rule__AttributeCS__Group_5_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_5_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5_1__1"


    // $ANTLR start "rule__AttributeCS__Group_5_1__1__Impl"
    // InternalQVTbase.g:5288:1: rule__AttributeCS__Group_5_1__1__Impl : ( ( ',' )? ) ;
    public final void rule__AttributeCS__Group_5_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5292:1: ( ( ( ',' )? ) )
            // InternalQVTbase.g:5293:1: ( ( ',' )? )
            {
            // InternalQVTbase.g:5293:1: ( ( ',' )? )
            // InternalQVTbase.g:5294:1: ( ',' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getCommaKeyword_5_1_1());
            }
            // InternalQVTbase.g:5295:1: ( ',' )?
            int alt64=2;
            int LA64_0 = input.LA(1);

            if ( (LA64_0==64) ) {
                alt64=1;
            }
            switch (alt64) {
                case 1 :
                    // InternalQVTbase.g:5296:2: ','
                    {
                    match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getCommaKeyword_5_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_5_1__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0__0"
    // InternalQVTbase.g:5311:1: rule__AttributeCS__Group_6_0__0 : rule__AttributeCS__Group_6_0__0__Impl rule__AttributeCS__Group_6_0__1 ;
    public final void rule__AttributeCS__Group_6_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5315:1: ( rule__AttributeCS__Group_6_0__0__Impl rule__AttributeCS__Group_6_0__1 )
            // InternalQVTbase.g:5316:2: rule__AttributeCS__Group_6_0__0__Impl rule__AttributeCS__Group_6_0__1
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__AttributeCS__Group_6_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__0"


    // $ANTLR start "rule__AttributeCS__Group_6_0__0__Impl"
    // InternalQVTbase.g:5323:1: rule__AttributeCS__Group_6_0__0__Impl : ( '{' ) ;
    public final void rule__AttributeCS__Group_6_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5327:1: ( ( '{' ) )
            // InternalQVTbase.g:5328:1: ( '{' )
            {
            // InternalQVTbase.g:5328:1: ( '{' )
            // InternalQVTbase.g:5329:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getLeftCurlyBracketKeyword_6_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getLeftCurlyBracketKeyword_6_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0__1"
    // InternalQVTbase.g:5342:1: rule__AttributeCS__Group_6_0__1 : rule__AttributeCS__Group_6_0__1__Impl rule__AttributeCS__Group_6_0__2 ;
    public final void rule__AttributeCS__Group_6_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5346:1: ( rule__AttributeCS__Group_6_0__1__Impl rule__AttributeCS__Group_6_0__2 )
            // InternalQVTbase.g:5347:2: rule__AttributeCS__Group_6_0__1__Impl rule__AttributeCS__Group_6_0__2
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__AttributeCS__Group_6_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__1"


    // $ANTLR start "rule__AttributeCS__Group_6_0__1__Impl"
    // InternalQVTbase.g:5354:1: rule__AttributeCS__Group_6_0__1__Impl : ( ( rule__AttributeCS__Alternatives_6_0_1 )* ) ;
    public final void rule__AttributeCS__Group_6_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5358:1: ( ( ( rule__AttributeCS__Alternatives_6_0_1 )* ) )
            // InternalQVTbase.g:5359:1: ( ( rule__AttributeCS__Alternatives_6_0_1 )* )
            {
            // InternalQVTbase.g:5359:1: ( ( rule__AttributeCS__Alternatives_6_0_1 )* )
            // InternalQVTbase.g:5360:1: ( rule__AttributeCS__Alternatives_6_0_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getAlternatives_6_0_1());
            }
            // InternalQVTbase.g:5361:1: ( rule__AttributeCS__Alternatives_6_0_1 )*
            loop65:
            do {
                int alt65=2;
                int LA65_0 = input.LA(1);

                if ( ((LA65_0>=65 && LA65_0<=66)) ) {
                    alt65=1;
                }


                switch (alt65) {
            	case 1 :
            	    // InternalQVTbase.g:5361:2: rule__AttributeCS__Alternatives_6_0_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_16);
            	    rule__AttributeCS__Alternatives_6_0_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop65;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getAlternatives_6_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0__2"
    // InternalQVTbase.g:5371:1: rule__AttributeCS__Group_6_0__2 : rule__AttributeCS__Group_6_0__2__Impl ;
    public final void rule__AttributeCS__Group_6_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5375:1: ( rule__AttributeCS__Group_6_0__2__Impl )
            // InternalQVTbase.g:5376:2: rule__AttributeCS__Group_6_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__2"


    // $ANTLR start "rule__AttributeCS__Group_6_0__2__Impl"
    // InternalQVTbase.g:5382:1: rule__AttributeCS__Group_6_0__2__Impl : ( '}' ) ;
    public final void rule__AttributeCS__Group_6_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5386:1: ( ( '}' ) )
            // InternalQVTbase.g:5387:1: ( '}' )
            {
            // InternalQVTbase.g:5387:1: ( '}' )
            // InternalQVTbase.g:5388:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getRightCurlyBracketKeyword_6_0_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getRightCurlyBracketKeyword_6_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0__2__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__0"
    // InternalQVTbase.g:5407:1: rule__AttributeCS__Group_6_0_1_0__0 : rule__AttributeCS__Group_6_0_1_0__0__Impl rule__AttributeCS__Group_6_0_1_0__1 ;
    public final void rule__AttributeCS__Group_6_0_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5411:1: ( rule__AttributeCS__Group_6_0_1_0__0__Impl rule__AttributeCS__Group_6_0_1_0__1 )
            // InternalQVTbase.g:5412:2: rule__AttributeCS__Group_6_0_1_0__0__Impl rule__AttributeCS__Group_6_0_1_0__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__AttributeCS__Group_6_0_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__0"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__0__Impl"
    // InternalQVTbase.g:5419:1: rule__AttributeCS__Group_6_0_1_0__0__Impl : ( 'initial' ) ;
    public final void rule__AttributeCS__Group_6_0_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5423:1: ( ( 'initial' ) )
            // InternalQVTbase.g:5424:1: ( 'initial' )
            {
            // InternalQVTbase.g:5424:1: ( 'initial' )
            // InternalQVTbase.g:5425:1: 'initial'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getInitialKeyword_6_0_1_0_0());
            }
            match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getInitialKeyword_6_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__1"
    // InternalQVTbase.g:5438:1: rule__AttributeCS__Group_6_0_1_0__1 : rule__AttributeCS__Group_6_0_1_0__1__Impl rule__AttributeCS__Group_6_0_1_0__2 ;
    public final void rule__AttributeCS__Group_6_0_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5442:1: ( rule__AttributeCS__Group_6_0_1_0__1__Impl rule__AttributeCS__Group_6_0_1_0__2 )
            // InternalQVTbase.g:5443:2: rule__AttributeCS__Group_6_0_1_0__1__Impl rule__AttributeCS__Group_6_0_1_0__2
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__AttributeCS__Group_6_0_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__1"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__1__Impl"
    // InternalQVTbase.g:5450:1: rule__AttributeCS__Group_6_0_1_0__1__Impl : ( ( ruleUnrestrictedName )? ) ;
    public final void rule__AttributeCS__Group_6_0_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5454:1: ( ( ( ruleUnrestrictedName )? ) )
            // InternalQVTbase.g:5455:1: ( ( ruleUnrestrictedName )? )
            {
            // InternalQVTbase.g:5455:1: ( ( ruleUnrestrictedName )? )
            // InternalQVTbase.g:5456:1: ( ruleUnrestrictedName )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getUnrestrictedNameParserRuleCall_6_0_1_0_1());
            }
            // InternalQVTbase.g:5457:1: ( ruleUnrestrictedName )?
            int alt66=2;
            int LA66_0 = input.LA(1);

            if ( ((LA66_0>=RULE_SIMPLE_ID && LA66_0<=RULE_ESCAPED_ID)) ) {
                alt66=1;
            }
            switch (alt66) {
                case 1 :
                    // InternalQVTbase.g:5457:3: ruleUnrestrictedName
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getUnrestrictedNameParserRuleCall_6_0_1_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__2"
    // InternalQVTbase.g:5467:1: rule__AttributeCS__Group_6_0_1_0__2 : rule__AttributeCS__Group_6_0_1_0__2__Impl rule__AttributeCS__Group_6_0_1_0__3 ;
    public final void rule__AttributeCS__Group_6_0_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5471:1: ( rule__AttributeCS__Group_6_0_1_0__2__Impl rule__AttributeCS__Group_6_0_1_0__3 )
            // InternalQVTbase.g:5472:2: rule__AttributeCS__Group_6_0_1_0__2__Impl rule__AttributeCS__Group_6_0_1_0__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__AttributeCS__Group_6_0_1_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_0__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__2"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__2__Impl"
    // InternalQVTbase.g:5479:1: rule__AttributeCS__Group_6_0_1_0__2__Impl : ( ':' ) ;
    public final void rule__AttributeCS__Group_6_0_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5483:1: ( ( ':' ) )
            // InternalQVTbase.g:5484:1: ( ':' )
            {
            // InternalQVTbase.g:5484:1: ( ':' )
            // InternalQVTbase.g:5485:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getColonKeyword_6_0_1_0_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getColonKeyword_6_0_1_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__2__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__3"
    // InternalQVTbase.g:5498:1: rule__AttributeCS__Group_6_0_1_0__3 : rule__AttributeCS__Group_6_0_1_0__3__Impl rule__AttributeCS__Group_6_0_1_0__4 ;
    public final void rule__AttributeCS__Group_6_0_1_0__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5502:1: ( rule__AttributeCS__Group_6_0_1_0__3__Impl rule__AttributeCS__Group_6_0_1_0__4 )
            // InternalQVTbase.g:5503:2: rule__AttributeCS__Group_6_0_1_0__3__Impl rule__AttributeCS__Group_6_0_1_0__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__AttributeCS__Group_6_0_1_0__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_0__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__3"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__3__Impl"
    // InternalQVTbase.g:5510:1: rule__AttributeCS__Group_6_0_1_0__3__Impl : ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )? ) ;
    public final void rule__AttributeCS__Group_6_0_1_0__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5514:1: ( ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )? ) )
            // InternalQVTbase.g:5515:1: ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )? )
            {
            // InternalQVTbase.g:5515:1: ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )? )
            // InternalQVTbase.g:5516:1: ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsAssignment_6_0_1_0_3());
            }
            // InternalQVTbase.g:5517:1: ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 )?
            int alt67=2;
            int LA67_0 = input.LA(1);

            if ( ((LA67_0>=RULE_INT && LA67_0<=RULE_UNQUOTED_STRING)||(LA67_0>=19 && LA67_0<=22)||(LA67_0>=43 && LA67_0<=57)||LA67_0==71||LA67_0==82||(LA67_0>=84 && LA67_0<=85)||LA67_0==90||(LA67_0>=95 && LA67_0<=96)||(LA67_0>=128 && LA67_0<=129)) ) {
                alt67=1;
            }
            switch (alt67) {
                case 1 :
                    // InternalQVTbase.g:5517:2: rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsAssignment_6_0_1_0_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__3__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__4"
    // InternalQVTbase.g:5527:1: rule__AttributeCS__Group_6_0_1_0__4 : rule__AttributeCS__Group_6_0_1_0__4__Impl ;
    public final void rule__AttributeCS__Group_6_0_1_0__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5531:1: ( rule__AttributeCS__Group_6_0_1_0__4__Impl )
            // InternalQVTbase.g:5532:2: rule__AttributeCS__Group_6_0_1_0__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_0__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__4"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_0__4__Impl"
    // InternalQVTbase.g:5538:1: rule__AttributeCS__Group_6_0_1_0__4__Impl : ( ';' ) ;
    public final void rule__AttributeCS__Group_6_0_1_0__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5542:1: ( ( ';' ) )
            // InternalQVTbase.g:5543:1: ( ';' )
            {
            // InternalQVTbase.g:5543:1: ( ';' )
            // InternalQVTbase.g:5544:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_0_1_0_4());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_0_1_0_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_0__4__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__0"
    // InternalQVTbase.g:5567:1: rule__AttributeCS__Group_6_0_1_1__0 : rule__AttributeCS__Group_6_0_1_1__0__Impl rule__AttributeCS__Group_6_0_1_1__1 ;
    public final void rule__AttributeCS__Group_6_0_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5571:1: ( rule__AttributeCS__Group_6_0_1_1__0__Impl rule__AttributeCS__Group_6_0_1_1__1 )
            // InternalQVTbase.g:5572:2: rule__AttributeCS__Group_6_0_1_1__0__Impl rule__AttributeCS__Group_6_0_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__AttributeCS__Group_6_0_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__0"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__0__Impl"
    // InternalQVTbase.g:5579:1: rule__AttributeCS__Group_6_0_1_1__0__Impl : ( 'derivation' ) ;
    public final void rule__AttributeCS__Group_6_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5583:1: ( ( 'derivation' ) )
            // InternalQVTbase.g:5584:1: ( 'derivation' )
            {
            // InternalQVTbase.g:5584:1: ( 'derivation' )
            // InternalQVTbase.g:5585:1: 'derivation'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getDerivationKeyword_6_0_1_1_0());
            }
            match(input,66,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getDerivationKeyword_6_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__0__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__1"
    // InternalQVTbase.g:5598:1: rule__AttributeCS__Group_6_0_1_1__1 : rule__AttributeCS__Group_6_0_1_1__1__Impl rule__AttributeCS__Group_6_0_1_1__2 ;
    public final void rule__AttributeCS__Group_6_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5602:1: ( rule__AttributeCS__Group_6_0_1_1__1__Impl rule__AttributeCS__Group_6_0_1_1__2 )
            // InternalQVTbase.g:5603:2: rule__AttributeCS__Group_6_0_1_1__1__Impl rule__AttributeCS__Group_6_0_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__AttributeCS__Group_6_0_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__1"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__1__Impl"
    // InternalQVTbase.g:5610:1: rule__AttributeCS__Group_6_0_1_1__1__Impl : ( ( ruleUnrestrictedName )? ) ;
    public final void rule__AttributeCS__Group_6_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5614:1: ( ( ( ruleUnrestrictedName )? ) )
            // InternalQVTbase.g:5615:1: ( ( ruleUnrestrictedName )? )
            {
            // InternalQVTbase.g:5615:1: ( ( ruleUnrestrictedName )? )
            // InternalQVTbase.g:5616:1: ( ruleUnrestrictedName )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getUnrestrictedNameParserRuleCall_6_0_1_1_1());
            }
            // InternalQVTbase.g:5617:1: ( ruleUnrestrictedName )?
            int alt68=2;
            int LA68_0 = input.LA(1);

            if ( ((LA68_0>=RULE_SIMPLE_ID && LA68_0<=RULE_ESCAPED_ID)) ) {
                alt68=1;
            }
            switch (alt68) {
                case 1 :
                    // InternalQVTbase.g:5617:3: ruleUnrestrictedName
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getUnrestrictedNameParserRuleCall_6_0_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__1__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__2"
    // InternalQVTbase.g:5627:1: rule__AttributeCS__Group_6_0_1_1__2 : rule__AttributeCS__Group_6_0_1_1__2__Impl rule__AttributeCS__Group_6_0_1_1__3 ;
    public final void rule__AttributeCS__Group_6_0_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5631:1: ( rule__AttributeCS__Group_6_0_1_1__2__Impl rule__AttributeCS__Group_6_0_1_1__3 )
            // InternalQVTbase.g:5632:2: rule__AttributeCS__Group_6_0_1_1__2__Impl rule__AttributeCS__Group_6_0_1_1__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__AttributeCS__Group_6_0_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__2"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__2__Impl"
    // InternalQVTbase.g:5639:1: rule__AttributeCS__Group_6_0_1_1__2__Impl : ( ':' ) ;
    public final void rule__AttributeCS__Group_6_0_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5643:1: ( ( ':' ) )
            // InternalQVTbase.g:5644:1: ( ':' )
            {
            // InternalQVTbase.g:5644:1: ( ':' )
            // InternalQVTbase.g:5645:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getColonKeyword_6_0_1_1_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getColonKeyword_6_0_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__2__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__3"
    // InternalQVTbase.g:5658:1: rule__AttributeCS__Group_6_0_1_1__3 : rule__AttributeCS__Group_6_0_1_1__3__Impl rule__AttributeCS__Group_6_0_1_1__4 ;
    public final void rule__AttributeCS__Group_6_0_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5662:1: ( rule__AttributeCS__Group_6_0_1_1__3__Impl rule__AttributeCS__Group_6_0_1_1__4 )
            // InternalQVTbase.g:5663:2: rule__AttributeCS__Group_6_0_1_1__3__Impl rule__AttributeCS__Group_6_0_1_1__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__AttributeCS__Group_6_0_1_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_1__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__3"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__3__Impl"
    // InternalQVTbase.g:5670:1: rule__AttributeCS__Group_6_0_1_1__3__Impl : ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )? ) ;
    public final void rule__AttributeCS__Group_6_0_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5674:1: ( ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )? ) )
            // InternalQVTbase.g:5675:1: ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )? )
            {
            // InternalQVTbase.g:5675:1: ( ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )? )
            // InternalQVTbase.g:5676:1: ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsAssignment_6_0_1_1_3());
            }
            // InternalQVTbase.g:5677:1: ( rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 )?
            int alt69=2;
            int LA69_0 = input.LA(1);

            if ( ((LA69_0>=RULE_INT && LA69_0<=RULE_UNQUOTED_STRING)||(LA69_0>=19 && LA69_0<=22)||(LA69_0>=43 && LA69_0<=57)||LA69_0==71||LA69_0==82||(LA69_0>=84 && LA69_0<=85)||LA69_0==90||(LA69_0>=95 && LA69_0<=96)||(LA69_0>=128 && LA69_0<=129)) ) {
                alt69=1;
            }
            switch (alt69) {
                case 1 :
                    // InternalQVTbase.g:5677:2: rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsAssignment_6_0_1_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__3__Impl"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__4"
    // InternalQVTbase.g:5687:1: rule__AttributeCS__Group_6_0_1_1__4 : rule__AttributeCS__Group_6_0_1_1__4__Impl ;
    public final void rule__AttributeCS__Group_6_0_1_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5691:1: ( rule__AttributeCS__Group_6_0_1_1__4__Impl )
            // InternalQVTbase.g:5692:2: rule__AttributeCS__Group_6_0_1_1__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__AttributeCS__Group_6_0_1_1__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__4"


    // $ANTLR start "rule__AttributeCS__Group_6_0_1_1__4__Impl"
    // InternalQVTbase.g:5698:1: rule__AttributeCS__Group_6_0_1_1__4__Impl : ( ';' ) ;
    public final void rule__AttributeCS__Group_6_0_1_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5702:1: ( ( ';' ) )
            // InternalQVTbase.g:5703:1: ( ';' )
            {
            // InternalQVTbase.g:5703:1: ( ';' )
            // InternalQVTbase.g:5704:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_0_1_1_4());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getSemicolonKeyword_6_0_1_1_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__Group_6_0_1_1__4__Impl"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__0"
    // InternalQVTbase.g:5727:1: rule__CompoundTargetElementCS__Group__0 : rule__CompoundTargetElementCS__Group__0__Impl rule__CompoundTargetElementCS__Group__1 ;
    public final void rule__CompoundTargetElementCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5731:1: ( rule__CompoundTargetElementCS__Group__0__Impl rule__CompoundTargetElementCS__Group__1 )
            // InternalQVTbase.g:5732:2: rule__CompoundTargetElementCS__Group__0__Impl rule__CompoundTargetElementCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_19);
            rule__CompoundTargetElementCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CompoundTargetElementCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__0"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__0__Impl"
    // InternalQVTbase.g:5739:1: rule__CompoundTargetElementCS__Group__0__Impl : ( '{' ) ;
    public final void rule__CompoundTargetElementCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5743:1: ( ( '{' ) )
            // InternalQVTbase.g:5744:1: ( '{' )
            {
            // InternalQVTbase.g:5744:1: ( '{' )
            // InternalQVTbase.g:5745:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getLeftCurlyBracketKeyword_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundTargetElementCSAccess().getLeftCurlyBracketKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__0__Impl"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__1"
    // InternalQVTbase.g:5758:1: rule__CompoundTargetElementCS__Group__1 : rule__CompoundTargetElementCS__Group__1__Impl rule__CompoundTargetElementCS__Group__2 ;
    public final void rule__CompoundTargetElementCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5762:1: ( rule__CompoundTargetElementCS__Group__1__Impl rule__CompoundTargetElementCS__Group__2 )
            // InternalQVTbase.g:5763:2: rule__CompoundTargetElementCS__Group__1__Impl rule__CompoundTargetElementCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_19);
            rule__CompoundTargetElementCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CompoundTargetElementCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__1"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__1__Impl"
    // InternalQVTbase.g:5770:1: rule__CompoundTargetElementCS__Group__1__Impl : ( ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )* ) ;
    public final void rule__CompoundTargetElementCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5774:1: ( ( ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )* ) )
            // InternalQVTbase.g:5775:1: ( ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )* )
            {
            // InternalQVTbase.g:5775:1: ( ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )* )
            // InternalQVTbase.g:5776:1: ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getOwnedTargetElementsAssignment_1());
            }
            // InternalQVTbase.g:5777:1: ( rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 )*
            loop70:
            do {
                int alt70=2;
                int LA70_0 = input.LA(1);

                if ( ((LA70_0>=123 && LA70_0<=125)) ) {
                    alt70=1;
                }


                switch (alt70) {
            	case 1 :
            	    // InternalQVTbase.g:5777:2: rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_20);
            	    rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop70;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundTargetElementCSAccess().getOwnedTargetElementsAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__1__Impl"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__2"
    // InternalQVTbase.g:5787:1: rule__CompoundTargetElementCS__Group__2 : rule__CompoundTargetElementCS__Group__2__Impl rule__CompoundTargetElementCS__Group__3 ;
    public final void rule__CompoundTargetElementCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5791:1: ( rule__CompoundTargetElementCS__Group__2__Impl rule__CompoundTargetElementCS__Group__3 )
            // InternalQVTbase.g:5792:2: rule__CompoundTargetElementCS__Group__2__Impl rule__CompoundTargetElementCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_21);
            rule__CompoundTargetElementCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CompoundTargetElementCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__2"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__2__Impl"
    // InternalQVTbase.g:5799:1: rule__CompoundTargetElementCS__Group__2__Impl : ( '}' ) ;
    public final void rule__CompoundTargetElementCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5803:1: ( ( '}' ) )
            // InternalQVTbase.g:5804:1: ( '}' )
            {
            // InternalQVTbase.g:5804:1: ( '}' )
            // InternalQVTbase.g:5805:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getRightCurlyBracketKeyword_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundTargetElementCSAccess().getRightCurlyBracketKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__2__Impl"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__3"
    // InternalQVTbase.g:5818:1: rule__CompoundTargetElementCS__Group__3 : rule__CompoundTargetElementCS__Group__3__Impl ;
    public final void rule__CompoundTargetElementCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5822:1: ( rule__CompoundTargetElementCS__Group__3__Impl )
            // InternalQVTbase.g:5823:2: rule__CompoundTargetElementCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CompoundTargetElementCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__3"


    // $ANTLR start "rule__CompoundTargetElementCS__Group__3__Impl"
    // InternalQVTbase.g:5829:1: rule__CompoundTargetElementCS__Group__3__Impl : ( ( ';' )? ) ;
    public final void rule__CompoundTargetElementCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5833:1: ( ( ( ';' )? ) )
            // InternalQVTbase.g:5834:1: ( ( ';' )? )
            {
            // InternalQVTbase.g:5834:1: ( ( ';' )? )
            // InternalQVTbase.g:5835:1: ( ';' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getSemicolonKeyword_3());
            }
            // InternalQVTbase.g:5836:1: ( ';' )?
            int alt71=2;
            int LA71_0 = input.LA(1);

            if ( (LA71_0==17) ) {
                alt71=1;
            }
            switch (alt71) {
                case 1 :
                    // InternalQVTbase.g:5837:2: ';'
                    {
                    match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundTargetElementCSAccess().getSemicolonKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__Group__3__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__0"
    // InternalQVTbase.g:5856:1: rule__DataTypeCS__Group__0 : rule__DataTypeCS__Group__0__Impl rule__DataTypeCS__Group__1 ;
    public final void rule__DataTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5860:1: ( rule__DataTypeCS__Group__0__Impl rule__DataTypeCS__Group__1 )
            // InternalQVTbase.g:5861:2: rule__DataTypeCS__Group__0__Impl rule__DataTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_22);
            rule__DataTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__0"


    // $ANTLR start "rule__DataTypeCS__Group__0__Impl"
    // InternalQVTbase.g:5868:1: rule__DataTypeCS__Group__0__Impl : ( ( rule__DataTypeCS__IsPrimitiveAssignment_0 )? ) ;
    public final void rule__DataTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5872:1: ( ( ( rule__DataTypeCS__IsPrimitiveAssignment_0 )? ) )
            // InternalQVTbase.g:5873:1: ( ( rule__DataTypeCS__IsPrimitiveAssignment_0 )? )
            {
            // InternalQVTbase.g:5873:1: ( ( rule__DataTypeCS__IsPrimitiveAssignment_0 )? )
            // InternalQVTbase.g:5874:1: ( rule__DataTypeCS__IsPrimitiveAssignment_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getIsPrimitiveAssignment_0());
            }
            // InternalQVTbase.g:5875:1: ( rule__DataTypeCS__IsPrimitiveAssignment_0 )?
            int alt72=2;
            int LA72_0 = input.LA(1);

            if ( (LA72_0==117) ) {
                alt72=1;
            }
            switch (alt72) {
                case 1 :
                    // InternalQVTbase.g:5875:2: rule__DataTypeCS__IsPrimitiveAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__IsPrimitiveAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getIsPrimitiveAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__0__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__1"
    // InternalQVTbase.g:5885:1: rule__DataTypeCS__Group__1 : rule__DataTypeCS__Group__1__Impl rule__DataTypeCS__Group__2 ;
    public final void rule__DataTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5889:1: ( rule__DataTypeCS__Group__1__Impl rule__DataTypeCS__Group__2 )
            // InternalQVTbase.g:5890:2: rule__DataTypeCS__Group__1__Impl rule__DataTypeCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__DataTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__1"


    // $ANTLR start "rule__DataTypeCS__Group__1__Impl"
    // InternalQVTbase.g:5897:1: rule__DataTypeCS__Group__1__Impl : ( 'datatype' ) ;
    public final void rule__DataTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5901:1: ( ( 'datatype' ) )
            // InternalQVTbase.g:5902:1: ( 'datatype' )
            {
            // InternalQVTbase.g:5902:1: ( 'datatype' )
            // InternalQVTbase.g:5903:1: 'datatype'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getDatatypeKeyword_1());
            }
            match(input,67,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getDatatypeKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__1__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__2"
    // InternalQVTbase.g:5916:1: rule__DataTypeCS__Group__2 : rule__DataTypeCS__Group__2__Impl rule__DataTypeCS__Group__3 ;
    public final void rule__DataTypeCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5920:1: ( rule__DataTypeCS__Group__2__Impl rule__DataTypeCS__Group__3 )
            // InternalQVTbase.g:5921:2: rule__DataTypeCS__Group__2__Impl rule__DataTypeCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__DataTypeCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__2"


    // $ANTLR start "rule__DataTypeCS__Group__2__Impl"
    // InternalQVTbase.g:5928:1: rule__DataTypeCS__Group__2__Impl : ( ( rule__DataTypeCS__NameAssignment_2 ) ) ;
    public final void rule__DataTypeCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5932:1: ( ( ( rule__DataTypeCS__NameAssignment_2 ) ) )
            // InternalQVTbase.g:5933:1: ( ( rule__DataTypeCS__NameAssignment_2 ) )
            {
            // InternalQVTbase.g:5933:1: ( ( rule__DataTypeCS__NameAssignment_2 ) )
            // InternalQVTbase.g:5934:1: ( rule__DataTypeCS__NameAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getNameAssignment_2());
            }
            // InternalQVTbase.g:5935:1: ( rule__DataTypeCS__NameAssignment_2 )
            // InternalQVTbase.g:5935:2: rule__DataTypeCS__NameAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__NameAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getNameAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__2__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__3"
    // InternalQVTbase.g:5945:1: rule__DataTypeCS__Group__3 : rule__DataTypeCS__Group__3__Impl rule__DataTypeCS__Group__4 ;
    public final void rule__DataTypeCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5949:1: ( rule__DataTypeCS__Group__3__Impl rule__DataTypeCS__Group__4 )
            // InternalQVTbase.g:5950:2: rule__DataTypeCS__Group__3__Impl rule__DataTypeCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__DataTypeCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__3"


    // $ANTLR start "rule__DataTypeCS__Group__3__Impl"
    // InternalQVTbase.g:5957:1: rule__DataTypeCS__Group__3__Impl : ( ( rule__DataTypeCS__OwnedSignatureAssignment_3 )? ) ;
    public final void rule__DataTypeCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5961:1: ( ( ( rule__DataTypeCS__OwnedSignatureAssignment_3 )? ) )
            // InternalQVTbase.g:5962:1: ( ( rule__DataTypeCS__OwnedSignatureAssignment_3 )? )
            {
            // InternalQVTbase.g:5962:1: ( ( rule__DataTypeCS__OwnedSignatureAssignment_3 )? )
            // InternalQVTbase.g:5963:1: ( rule__DataTypeCS__OwnedSignatureAssignment_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getOwnedSignatureAssignment_3());
            }
            // InternalQVTbase.g:5964:1: ( rule__DataTypeCS__OwnedSignatureAssignment_3 )?
            int alt73=2;
            int LA73_0 = input.LA(1);

            if ( (LA73_0==71) ) {
                alt73=1;
            }
            switch (alt73) {
                case 1 :
                    // InternalQVTbase.g:5964:2: rule__DataTypeCS__OwnedSignatureAssignment_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__OwnedSignatureAssignment_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getOwnedSignatureAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__3__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__4"
    // InternalQVTbase.g:5974:1: rule__DataTypeCS__Group__4 : rule__DataTypeCS__Group__4__Impl rule__DataTypeCS__Group__5 ;
    public final void rule__DataTypeCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5978:1: ( rule__DataTypeCS__Group__4__Impl rule__DataTypeCS__Group__5 )
            // InternalQVTbase.g:5979:2: rule__DataTypeCS__Group__4__Impl rule__DataTypeCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__DataTypeCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__4"


    // $ANTLR start "rule__DataTypeCS__Group__4__Impl"
    // InternalQVTbase.g:5986:1: rule__DataTypeCS__Group__4__Impl : ( ( rule__DataTypeCS__Group_4__0 )? ) ;
    public final void rule__DataTypeCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:5990:1: ( ( ( rule__DataTypeCS__Group_4__0 )? ) )
            // InternalQVTbase.g:5991:1: ( ( rule__DataTypeCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:5991:1: ( ( rule__DataTypeCS__Group_4__0 )? )
            // InternalQVTbase.g:5992:1: ( rule__DataTypeCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:5993:1: ( rule__DataTypeCS__Group_4__0 )?
            int alt74=2;
            int LA74_0 = input.LA(1);

            if ( (LA74_0==61) ) {
                alt74=1;
            }
            switch (alt74) {
                case 1 :
                    // InternalQVTbase.g:5993:2: rule__DataTypeCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__4__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__5"
    // InternalQVTbase.g:6003:1: rule__DataTypeCS__Group__5 : rule__DataTypeCS__Group__5__Impl rule__DataTypeCS__Group__6 ;
    public final void rule__DataTypeCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6007:1: ( rule__DataTypeCS__Group__5__Impl rule__DataTypeCS__Group__6 )
            // InternalQVTbase.g:6008:2: rule__DataTypeCS__Group__5__Impl rule__DataTypeCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__DataTypeCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__5"


    // $ANTLR start "rule__DataTypeCS__Group__5__Impl"
    // InternalQVTbase.g:6015:1: rule__DataTypeCS__Group__5__Impl : ( ( rule__DataTypeCS__Group_5__0 )? ) ;
    public final void rule__DataTypeCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6019:1: ( ( ( rule__DataTypeCS__Group_5__0 )? ) )
            // InternalQVTbase.g:6020:1: ( ( rule__DataTypeCS__Group_5__0 )? )
            {
            // InternalQVTbase.g:6020:1: ( ( rule__DataTypeCS__Group_5__0 )? )
            // InternalQVTbase.g:6021:1: ( rule__DataTypeCS__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getGroup_5());
            }
            // InternalQVTbase.g:6022:1: ( rule__DataTypeCS__Group_5__0 )?
            int alt75=2;
            int LA75_0 = input.LA(1);

            if ( (LA75_0==62) ) {
                int LA75_1 = input.LA(2);

                if ( (LA75_1==18||LA75_1==118) ) {
                    alt75=1;
                }
                else if ( (LA75_1==63) ) {
                    int LA75_4 = input.LA(3);

                    if ( (LA75_4==17||LA75_4==62) ) {
                        alt75=1;
                    }
                }
            }
            switch (alt75) {
                case 1 :
                    // InternalQVTbase.g:6022:2: rule__DataTypeCS__Group_5__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getGroup_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__5__Impl"


    // $ANTLR start "rule__DataTypeCS__Group__6"
    // InternalQVTbase.g:6032:1: rule__DataTypeCS__Group__6 : rule__DataTypeCS__Group__6__Impl ;
    public final void rule__DataTypeCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6036:1: ( rule__DataTypeCS__Group__6__Impl )
            // InternalQVTbase.g:6037:2: rule__DataTypeCS__Group__6__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__6"


    // $ANTLR start "rule__DataTypeCS__Group__6__Impl"
    // InternalQVTbase.g:6043:1: rule__DataTypeCS__Group__6__Impl : ( ( rule__DataTypeCS__Alternatives_6 ) ) ;
    public final void rule__DataTypeCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6047:1: ( ( ( rule__DataTypeCS__Alternatives_6 ) ) )
            // InternalQVTbase.g:6048:1: ( ( rule__DataTypeCS__Alternatives_6 ) )
            {
            // InternalQVTbase.g:6048:1: ( ( rule__DataTypeCS__Alternatives_6 ) )
            // InternalQVTbase.g:6049:1: ( rule__DataTypeCS__Alternatives_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getAlternatives_6());
            }
            // InternalQVTbase.g:6050:1: ( rule__DataTypeCS__Alternatives_6 )
            // InternalQVTbase.g:6050:2: rule__DataTypeCS__Alternatives_6
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Alternatives_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getAlternatives_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group__6__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_4__0"
    // InternalQVTbase.g:6074:1: rule__DataTypeCS__Group_4__0 : rule__DataTypeCS__Group_4__0__Impl rule__DataTypeCS__Group_4__1 ;
    public final void rule__DataTypeCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6078:1: ( rule__DataTypeCS__Group_4__0__Impl rule__DataTypeCS__Group_4__1 )
            // InternalQVTbase.g:6079:2: rule__DataTypeCS__Group_4__0__Impl rule__DataTypeCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__DataTypeCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_4__0"


    // $ANTLR start "rule__DataTypeCS__Group_4__0__Impl"
    // InternalQVTbase.g:6086:1: rule__DataTypeCS__Group_4__0__Impl : ( ':' ) ;
    public final void rule__DataTypeCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6090:1: ( ( ':' ) )
            // InternalQVTbase.g:6091:1: ( ':' )
            {
            // InternalQVTbase.g:6091:1: ( ':' )
            // InternalQVTbase.g:6092:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getColonKeyword_4_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getColonKeyword_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_4__0__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_4__1"
    // InternalQVTbase.g:6105:1: rule__DataTypeCS__Group_4__1 : rule__DataTypeCS__Group_4__1__Impl ;
    public final void rule__DataTypeCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6109:1: ( rule__DataTypeCS__Group_4__1__Impl )
            // InternalQVTbase.g:6110:2: rule__DataTypeCS__Group_4__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_4__1"


    // $ANTLR start "rule__DataTypeCS__Group_4__1__Impl"
    // InternalQVTbase.g:6116:1: rule__DataTypeCS__Group_4__1__Impl : ( ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 ) ) ;
    public final void rule__DataTypeCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6120:1: ( ( ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 ) ) )
            // InternalQVTbase.g:6121:1: ( ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 ) )
            {
            // InternalQVTbase.g:6121:1: ( ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 ) )
            // InternalQVTbase.g:6122:1: ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getInstanceClassNameAssignment_4_1());
            }
            // InternalQVTbase.g:6123:1: ( rule__DataTypeCS__InstanceClassNameAssignment_4_1 )
            // InternalQVTbase.g:6123:2: rule__DataTypeCS__InstanceClassNameAssignment_4_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__InstanceClassNameAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getInstanceClassNameAssignment_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_4__1__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_5__0"
    // InternalQVTbase.g:6137:1: rule__DataTypeCS__Group_5__0 : rule__DataTypeCS__Group_5__0__Impl rule__DataTypeCS__Group_5__1 ;
    public final void rule__DataTypeCS__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6141:1: ( rule__DataTypeCS__Group_5__0__Impl rule__DataTypeCS__Group_5__1 )
            // InternalQVTbase.g:6142:2: rule__DataTypeCS__Group_5__0__Impl rule__DataTypeCS__Group_5__1
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__DataTypeCS__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__0"


    // $ANTLR start "rule__DataTypeCS__Group_5__0__Impl"
    // InternalQVTbase.g:6149:1: rule__DataTypeCS__Group_5__0__Impl : ( '{' ) ;
    public final void rule__DataTypeCS__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6153:1: ( ( '{' ) )
            // InternalQVTbase.g:6154:1: ( '{' )
            {
            // InternalQVTbase.g:6154:1: ( '{' )
            // InternalQVTbase.g:6155:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getLeftCurlyBracketKeyword_5_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getLeftCurlyBracketKeyword_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__0__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_5__1"
    // InternalQVTbase.g:6168:1: rule__DataTypeCS__Group_5__1 : rule__DataTypeCS__Group_5__1__Impl rule__DataTypeCS__Group_5__2 ;
    public final void rule__DataTypeCS__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6172:1: ( rule__DataTypeCS__Group_5__1__Impl rule__DataTypeCS__Group_5__2 )
            // InternalQVTbase.g:6173:2: rule__DataTypeCS__Group_5__1__Impl rule__DataTypeCS__Group_5__2
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__DataTypeCS__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_5__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__1"


    // $ANTLR start "rule__DataTypeCS__Group_5__1__Impl"
    // InternalQVTbase.g:6180:1: rule__DataTypeCS__Group_5__1__Impl : ( ( rule__DataTypeCS__Alternatives_5_1 )? ) ;
    public final void rule__DataTypeCS__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6184:1: ( ( ( rule__DataTypeCS__Alternatives_5_1 )? ) )
            // InternalQVTbase.g:6185:1: ( ( rule__DataTypeCS__Alternatives_5_1 )? )
            {
            // InternalQVTbase.g:6185:1: ( ( rule__DataTypeCS__Alternatives_5_1 )? )
            // InternalQVTbase.g:6186:1: ( rule__DataTypeCS__Alternatives_5_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getAlternatives_5_1());
            }
            // InternalQVTbase.g:6187:1: ( rule__DataTypeCS__Alternatives_5_1 )?
            int alt76=2;
            int LA76_0 = input.LA(1);

            if ( (LA76_0==18||LA76_0==118) ) {
                alt76=1;
            }
            switch (alt76) {
                case 1 :
                    // InternalQVTbase.g:6187:2: rule__DataTypeCS__Alternatives_5_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__DataTypeCS__Alternatives_5_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getAlternatives_5_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__1__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_5__2"
    // InternalQVTbase.g:6197:1: rule__DataTypeCS__Group_5__2 : rule__DataTypeCS__Group_5__2__Impl ;
    public final void rule__DataTypeCS__Group_5__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6201:1: ( rule__DataTypeCS__Group_5__2__Impl )
            // InternalQVTbase.g:6202:2: rule__DataTypeCS__Group_5__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_5__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__2"


    // $ANTLR start "rule__DataTypeCS__Group_5__2__Impl"
    // InternalQVTbase.g:6208:1: rule__DataTypeCS__Group_5__2__Impl : ( '}' ) ;
    public final void rule__DataTypeCS__Group_5__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6212:1: ( ( '}' ) )
            // InternalQVTbase.g:6213:1: ( '}' )
            {
            // InternalQVTbase.g:6213:1: ( '}' )
            // InternalQVTbase.g:6214:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getRightCurlyBracketKeyword_5_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getRightCurlyBracketKeyword_5_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_5__2__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_6_0__0"
    // InternalQVTbase.g:6233:1: rule__DataTypeCS__Group_6_0__0 : rule__DataTypeCS__Group_6_0__0__Impl rule__DataTypeCS__Group_6_0__1 ;
    public final void rule__DataTypeCS__Group_6_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6237:1: ( rule__DataTypeCS__Group_6_0__0__Impl rule__DataTypeCS__Group_6_0__1 )
            // InternalQVTbase.g:6238:2: rule__DataTypeCS__Group_6_0__0__Impl rule__DataTypeCS__Group_6_0__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__DataTypeCS__Group_6_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_6_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_6_0__0"


    // $ANTLR start "rule__DataTypeCS__Group_6_0__0__Impl"
    // InternalQVTbase.g:6245:1: rule__DataTypeCS__Group_6_0__0__Impl : ( '{' ) ;
    public final void rule__DataTypeCS__Group_6_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6249:1: ( ( '{' ) )
            // InternalQVTbase.g:6250:1: ( '{' )
            {
            // InternalQVTbase.g:6250:1: ( '{' )
            // InternalQVTbase.g:6251:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getLeftCurlyBracketKeyword_6_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getLeftCurlyBracketKeyword_6_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_6_0__0__Impl"


    // $ANTLR start "rule__DataTypeCS__Group_6_0__1"
    // InternalQVTbase.g:6264:1: rule__DataTypeCS__Group_6_0__1 : rule__DataTypeCS__Group_6_0__1__Impl ;
    public final void rule__DataTypeCS__Group_6_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6268:1: ( rule__DataTypeCS__Group_6_0__1__Impl )
            // InternalQVTbase.g:6269:2: rule__DataTypeCS__Group_6_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__DataTypeCS__Group_6_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_6_0__1"


    // $ANTLR start "rule__DataTypeCS__Group_6_0__1__Impl"
    // InternalQVTbase.g:6275:1: rule__DataTypeCS__Group_6_0__1__Impl : ( '}' ) ;
    public final void rule__DataTypeCS__Group_6_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6279:1: ( ( '}' ) )
            // InternalQVTbase.g:6280:1: ( '}' )
            {
            // InternalQVTbase.g:6280:1: ( '}' )
            // InternalQVTbase.g:6281:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getRightCurlyBracketKeyword_6_0_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getRightCurlyBracketKeyword_6_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__Group_6_0__1__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__0"
    // InternalQVTbase.g:6298:1: rule__EnumerationCS__Group__0 : rule__EnumerationCS__Group__0__Impl rule__EnumerationCS__Group__1 ;
    public final void rule__EnumerationCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6302:1: ( rule__EnumerationCS__Group__0__Impl rule__EnumerationCS__Group__1 )
            // InternalQVTbase.g:6303:2: rule__EnumerationCS__Group__0__Impl rule__EnumerationCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__EnumerationCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__0"


    // $ANTLR start "rule__EnumerationCS__Group__0__Impl"
    // InternalQVTbase.g:6310:1: rule__EnumerationCS__Group__0__Impl : ( 'enum' ) ;
    public final void rule__EnumerationCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6314:1: ( ( 'enum' ) )
            // InternalQVTbase.g:6315:1: ( 'enum' )
            {
            // InternalQVTbase.g:6315:1: ( 'enum' )
            // InternalQVTbase.g:6316:1: 'enum'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getEnumKeyword_0());
            }
            match(input,68,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getEnumKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__0__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__1"
    // InternalQVTbase.g:6329:1: rule__EnumerationCS__Group__1 : rule__EnumerationCS__Group__1__Impl rule__EnumerationCS__Group__2 ;
    public final void rule__EnumerationCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6333:1: ( rule__EnumerationCS__Group__1__Impl rule__EnumerationCS__Group__2 )
            // InternalQVTbase.g:6334:2: rule__EnumerationCS__Group__1__Impl rule__EnumerationCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__EnumerationCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__1"


    // $ANTLR start "rule__EnumerationCS__Group__1__Impl"
    // InternalQVTbase.g:6341:1: rule__EnumerationCS__Group__1__Impl : ( ( rule__EnumerationCS__NameAssignment_1 ) ) ;
    public final void rule__EnumerationCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6345:1: ( ( ( rule__EnumerationCS__NameAssignment_1 ) ) )
            // InternalQVTbase.g:6346:1: ( ( rule__EnumerationCS__NameAssignment_1 ) )
            {
            // InternalQVTbase.g:6346:1: ( ( rule__EnumerationCS__NameAssignment_1 ) )
            // InternalQVTbase.g:6347:1: ( rule__EnumerationCS__NameAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getNameAssignment_1());
            }
            // InternalQVTbase.g:6348:1: ( rule__EnumerationCS__NameAssignment_1 )
            // InternalQVTbase.g:6348:2: rule__EnumerationCS__NameAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__NameAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getNameAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__1__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__2"
    // InternalQVTbase.g:6358:1: rule__EnumerationCS__Group__2 : rule__EnumerationCS__Group__2__Impl rule__EnumerationCS__Group__3 ;
    public final void rule__EnumerationCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6362:1: ( rule__EnumerationCS__Group__2__Impl rule__EnumerationCS__Group__3 )
            // InternalQVTbase.g:6363:2: rule__EnumerationCS__Group__2__Impl rule__EnumerationCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__EnumerationCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__2"


    // $ANTLR start "rule__EnumerationCS__Group__2__Impl"
    // InternalQVTbase.g:6370:1: rule__EnumerationCS__Group__2__Impl : ( ( rule__EnumerationCS__OwnedSignatureAssignment_2 )? ) ;
    public final void rule__EnumerationCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6374:1: ( ( ( rule__EnumerationCS__OwnedSignatureAssignment_2 )? ) )
            // InternalQVTbase.g:6375:1: ( ( rule__EnumerationCS__OwnedSignatureAssignment_2 )? )
            {
            // InternalQVTbase.g:6375:1: ( ( rule__EnumerationCS__OwnedSignatureAssignment_2 )? )
            // InternalQVTbase.g:6376:1: ( rule__EnumerationCS__OwnedSignatureAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getOwnedSignatureAssignment_2());
            }
            // InternalQVTbase.g:6377:1: ( rule__EnumerationCS__OwnedSignatureAssignment_2 )?
            int alt77=2;
            int LA77_0 = input.LA(1);

            if ( (LA77_0==71) ) {
                alt77=1;
            }
            switch (alt77) {
                case 1 :
                    // InternalQVTbase.g:6377:2: rule__EnumerationCS__OwnedSignatureAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__OwnedSignatureAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getOwnedSignatureAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__2__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__3"
    // InternalQVTbase.g:6387:1: rule__EnumerationCS__Group__3 : rule__EnumerationCS__Group__3__Impl rule__EnumerationCS__Group__4 ;
    public final void rule__EnumerationCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6391:1: ( rule__EnumerationCS__Group__3__Impl rule__EnumerationCS__Group__4 )
            // InternalQVTbase.g:6392:2: rule__EnumerationCS__Group__3__Impl rule__EnumerationCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__EnumerationCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__3"


    // $ANTLR start "rule__EnumerationCS__Group__3__Impl"
    // InternalQVTbase.g:6399:1: rule__EnumerationCS__Group__3__Impl : ( ( rule__EnumerationCS__Group_3__0 )? ) ;
    public final void rule__EnumerationCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6403:1: ( ( ( rule__EnumerationCS__Group_3__0 )? ) )
            // InternalQVTbase.g:6404:1: ( ( rule__EnumerationCS__Group_3__0 )? )
            {
            // InternalQVTbase.g:6404:1: ( ( rule__EnumerationCS__Group_3__0 )? )
            // InternalQVTbase.g:6405:1: ( rule__EnumerationCS__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getGroup_3());
            }
            // InternalQVTbase.g:6406:1: ( rule__EnumerationCS__Group_3__0 )?
            int alt78=2;
            int LA78_0 = input.LA(1);

            if ( (LA78_0==61) ) {
                alt78=1;
            }
            switch (alt78) {
                case 1 :
                    // InternalQVTbase.g:6406:2: rule__EnumerationCS__Group_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__3__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__4"
    // InternalQVTbase.g:6416:1: rule__EnumerationCS__Group__4 : rule__EnumerationCS__Group__4__Impl rule__EnumerationCS__Group__5 ;
    public final void rule__EnumerationCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6420:1: ( rule__EnumerationCS__Group__4__Impl rule__EnumerationCS__Group__5 )
            // InternalQVTbase.g:6421:2: rule__EnumerationCS__Group__4__Impl rule__EnumerationCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_23);
            rule__EnumerationCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__4"


    // $ANTLR start "rule__EnumerationCS__Group__4__Impl"
    // InternalQVTbase.g:6428:1: rule__EnumerationCS__Group__4__Impl : ( ( rule__EnumerationCS__Group_4__0 )? ) ;
    public final void rule__EnumerationCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6432:1: ( ( ( rule__EnumerationCS__Group_4__0 )? ) )
            // InternalQVTbase.g:6433:1: ( ( rule__EnumerationCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:6433:1: ( ( rule__EnumerationCS__Group_4__0 )? )
            // InternalQVTbase.g:6434:1: ( rule__EnumerationCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:6435:1: ( rule__EnumerationCS__Group_4__0 )?
            int alt79=2;
            int LA79_0 = input.LA(1);

            if ( (LA79_0==62) ) {
                int LA79_1 = input.LA(2);

                if ( (LA79_1==18||LA79_1==118) ) {
                    alt79=1;
                }
                else if ( (LA79_1==63) ) {
                    int LA79_4 = input.LA(3);

                    if ( (LA79_4==17||LA79_4==62) ) {
                        alt79=1;
                    }
                }
            }
            switch (alt79) {
                case 1 :
                    // InternalQVTbase.g:6435:2: rule__EnumerationCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__4__Impl"


    // $ANTLR start "rule__EnumerationCS__Group__5"
    // InternalQVTbase.g:6445:1: rule__EnumerationCS__Group__5 : rule__EnumerationCS__Group__5__Impl ;
    public final void rule__EnumerationCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6449:1: ( rule__EnumerationCS__Group__5__Impl )
            // InternalQVTbase.g:6450:2: rule__EnumerationCS__Group__5__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__5"


    // $ANTLR start "rule__EnumerationCS__Group__5__Impl"
    // InternalQVTbase.g:6456:1: rule__EnumerationCS__Group__5__Impl : ( ( rule__EnumerationCS__Alternatives_5 ) ) ;
    public final void rule__EnumerationCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6460:1: ( ( ( rule__EnumerationCS__Alternatives_5 ) ) )
            // InternalQVTbase.g:6461:1: ( ( rule__EnumerationCS__Alternatives_5 ) )
            {
            // InternalQVTbase.g:6461:1: ( ( rule__EnumerationCS__Alternatives_5 ) )
            // InternalQVTbase.g:6462:1: ( rule__EnumerationCS__Alternatives_5 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getAlternatives_5());
            }
            // InternalQVTbase.g:6463:1: ( rule__EnumerationCS__Alternatives_5 )
            // InternalQVTbase.g:6463:2: rule__EnumerationCS__Alternatives_5
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Alternatives_5();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getAlternatives_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group__5__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_3__0"
    // InternalQVTbase.g:6485:1: rule__EnumerationCS__Group_3__0 : rule__EnumerationCS__Group_3__0__Impl rule__EnumerationCS__Group_3__1 ;
    public final void rule__EnumerationCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6489:1: ( rule__EnumerationCS__Group_3__0__Impl rule__EnumerationCS__Group_3__1 )
            // InternalQVTbase.g:6490:2: rule__EnumerationCS__Group_3__0__Impl rule__EnumerationCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__EnumerationCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_3__0"


    // $ANTLR start "rule__EnumerationCS__Group_3__0__Impl"
    // InternalQVTbase.g:6497:1: rule__EnumerationCS__Group_3__0__Impl : ( ':' ) ;
    public final void rule__EnumerationCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6501:1: ( ( ':' ) )
            // InternalQVTbase.g:6502:1: ( ':' )
            {
            // InternalQVTbase.g:6502:1: ( ':' )
            // InternalQVTbase.g:6503:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getColonKeyword_3_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getColonKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_3__0__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_3__1"
    // InternalQVTbase.g:6516:1: rule__EnumerationCS__Group_3__1 : rule__EnumerationCS__Group_3__1__Impl ;
    public final void rule__EnumerationCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6520:1: ( rule__EnumerationCS__Group_3__1__Impl )
            // InternalQVTbase.g:6521:2: rule__EnumerationCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__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__EnumerationCS__Group_3__1"


    // $ANTLR start "rule__EnumerationCS__Group_3__1__Impl"
    // InternalQVTbase.g:6527:1: rule__EnumerationCS__Group_3__1__Impl : ( ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 ) ) ;
    public final void rule__EnumerationCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6531:1: ( ( ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 ) ) )
            // InternalQVTbase.g:6532:1: ( ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 ) )
            {
            // InternalQVTbase.g:6532:1: ( ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 ) )
            // InternalQVTbase.g:6533:1: ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getInstanceClassNameAssignment_3_1());
            }
            // InternalQVTbase.g:6534:1: ( rule__EnumerationCS__InstanceClassNameAssignment_3_1 )
            // InternalQVTbase.g:6534:2: rule__EnumerationCS__InstanceClassNameAssignment_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__InstanceClassNameAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getInstanceClassNameAssignment_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_3__1__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_4__0"
    // InternalQVTbase.g:6548:1: rule__EnumerationCS__Group_4__0 : rule__EnumerationCS__Group_4__0__Impl rule__EnumerationCS__Group_4__1 ;
    public final void rule__EnumerationCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6552:1: ( rule__EnumerationCS__Group_4__0__Impl rule__EnumerationCS__Group_4__1 )
            // InternalQVTbase.g:6553:2: rule__EnumerationCS__Group_4__0__Impl rule__EnumerationCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__EnumerationCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__0"


    // $ANTLR start "rule__EnumerationCS__Group_4__0__Impl"
    // InternalQVTbase.g:6560:1: rule__EnumerationCS__Group_4__0__Impl : ( '{' ) ;
    public final void rule__EnumerationCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6564:1: ( ( '{' ) )
            // InternalQVTbase.g:6565:1: ( '{' )
            {
            // InternalQVTbase.g:6565:1: ( '{' )
            // InternalQVTbase.g:6566:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getLeftCurlyBracketKeyword_4_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getLeftCurlyBracketKeyword_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__0__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_4__1"
    // InternalQVTbase.g:6579:1: rule__EnumerationCS__Group_4__1 : rule__EnumerationCS__Group_4__1__Impl rule__EnumerationCS__Group_4__2 ;
    public final void rule__EnumerationCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6583:1: ( rule__EnumerationCS__Group_4__1__Impl rule__EnumerationCS__Group_4__2 )
            // InternalQVTbase.g:6584:2: rule__EnumerationCS__Group_4__1__Impl rule__EnumerationCS__Group_4__2
            {
            pushFollow(FollowSets000.FOLLOW_24);
            rule__EnumerationCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_4__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__1"


    // $ANTLR start "rule__EnumerationCS__Group_4__1__Impl"
    // InternalQVTbase.g:6591:1: rule__EnumerationCS__Group_4__1__Impl : ( ( rule__EnumerationCS__Alternatives_4_1 )? ) ;
    public final void rule__EnumerationCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6595:1: ( ( ( rule__EnumerationCS__Alternatives_4_1 )? ) )
            // InternalQVTbase.g:6596:1: ( ( rule__EnumerationCS__Alternatives_4_1 )? )
            {
            // InternalQVTbase.g:6596:1: ( ( rule__EnumerationCS__Alternatives_4_1 )? )
            // InternalQVTbase.g:6597:1: ( rule__EnumerationCS__Alternatives_4_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getAlternatives_4_1());
            }
            // InternalQVTbase.g:6598:1: ( rule__EnumerationCS__Alternatives_4_1 )?
            int alt80=2;
            int LA80_0 = input.LA(1);

            if ( (LA80_0==18||LA80_0==118) ) {
                alt80=1;
            }
            switch (alt80) {
                case 1 :
                    // InternalQVTbase.g:6598:2: rule__EnumerationCS__Alternatives_4_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationCS__Alternatives_4_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getAlternatives_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__1__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_4__2"
    // InternalQVTbase.g:6608:1: rule__EnumerationCS__Group_4__2 : rule__EnumerationCS__Group_4__2__Impl ;
    public final void rule__EnumerationCS__Group_4__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6612:1: ( rule__EnumerationCS__Group_4__2__Impl )
            // InternalQVTbase.g:6613:2: rule__EnumerationCS__Group_4__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_4__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__2"


    // $ANTLR start "rule__EnumerationCS__Group_4__2__Impl"
    // InternalQVTbase.g:6619:1: rule__EnumerationCS__Group_4__2__Impl : ( '}' ) ;
    public final void rule__EnumerationCS__Group_4__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6623:1: ( ( '}' ) )
            // InternalQVTbase.g:6624:1: ( '}' )
            {
            // InternalQVTbase.g:6624:1: ( '}' )
            // InternalQVTbase.g:6625:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getRightCurlyBracketKeyword_4_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getRightCurlyBracketKeyword_4_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_4__2__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__0"
    // InternalQVTbase.g:6644:1: rule__EnumerationCS__Group_5_0__0 : rule__EnumerationCS__Group_5_0__0__Impl rule__EnumerationCS__Group_5_0__1 ;
    public final void rule__EnumerationCS__Group_5_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6648:1: ( rule__EnumerationCS__Group_5_0__0__Impl rule__EnumerationCS__Group_5_0__1 )
            // InternalQVTbase.g:6649:2: rule__EnumerationCS__Group_5_0__0__Impl rule__EnumerationCS__Group_5_0__1
            {
            pushFollow(FollowSets000.FOLLOW_25);
            rule__EnumerationCS__Group_5_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_5_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__0"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__0__Impl"
    // InternalQVTbase.g:6656:1: rule__EnumerationCS__Group_5_0__0__Impl : ( '{' ) ;
    public final void rule__EnumerationCS__Group_5_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6660:1: ( ( '{' ) )
            // InternalQVTbase.g:6661:1: ( '{' )
            {
            // InternalQVTbase.g:6661:1: ( '{' )
            // InternalQVTbase.g:6662:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getLeftCurlyBracketKeyword_5_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getLeftCurlyBracketKeyword_5_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__0__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__1"
    // InternalQVTbase.g:6675:1: rule__EnumerationCS__Group_5_0__1 : rule__EnumerationCS__Group_5_0__1__Impl rule__EnumerationCS__Group_5_0__2 ;
    public final void rule__EnumerationCS__Group_5_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6679:1: ( rule__EnumerationCS__Group_5_0__1__Impl rule__EnumerationCS__Group_5_0__2 )
            // InternalQVTbase.g:6680:2: rule__EnumerationCS__Group_5_0__1__Impl rule__EnumerationCS__Group_5_0__2
            {
            pushFollow(FollowSets000.FOLLOW_25);
            rule__EnumerationCS__Group_5_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_5_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__1"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__1__Impl"
    // InternalQVTbase.g:6687:1: rule__EnumerationCS__Group_5_0__1__Impl : ( ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )* ) ;
    public final void rule__EnumerationCS__Group_5_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6691:1: ( ( ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )* ) )
            // InternalQVTbase.g:6692:1: ( ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )* )
            {
            // InternalQVTbase.g:6692:1: ( ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )* )
            // InternalQVTbase.g:6693:1: ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getOwnedLiteralsAssignment_5_0_1());
            }
            // InternalQVTbase.g:6694:1: ( rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 )*
            loop81:
            do {
                int alt81=2;
                int LA81_0 = input.LA(1);

                if ( ((LA81_0>=RULE_SIMPLE_ID && LA81_0<=RULE_ESCAPED_ID)||LA81_0==69) ) {
                    alt81=1;
                }


                switch (alt81) {
            	case 1 :
            	    // InternalQVTbase.g:6694:2: rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_26);
            	    rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop81;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getOwnedLiteralsAssignment_5_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__1__Impl"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__2"
    // InternalQVTbase.g:6704:1: rule__EnumerationCS__Group_5_0__2 : rule__EnumerationCS__Group_5_0__2__Impl ;
    public final void rule__EnumerationCS__Group_5_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6708:1: ( rule__EnumerationCS__Group_5_0__2__Impl )
            // InternalQVTbase.g:6709:2: rule__EnumerationCS__Group_5_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationCS__Group_5_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__2"


    // $ANTLR start "rule__EnumerationCS__Group_5_0__2__Impl"
    // InternalQVTbase.g:6715:1: rule__EnumerationCS__Group_5_0__2__Impl : ( '}' ) ;
    public final void rule__EnumerationCS__Group_5_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6719:1: ( ( '}' ) )
            // InternalQVTbase.g:6720:1: ( '}' )
            {
            // InternalQVTbase.g:6720:1: ( '}' )
            // InternalQVTbase.g:6721:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getRightCurlyBracketKeyword_5_0_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getRightCurlyBracketKeyword_5_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__Group_5_0__2__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__0"
    // InternalQVTbase.g:6740:1: rule__EnumerationLiteralCS__Group__0 : rule__EnumerationLiteralCS__Group__0__Impl rule__EnumerationLiteralCS__Group__1 ;
    public final void rule__EnumerationLiteralCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6744:1: ( rule__EnumerationLiteralCS__Group__0__Impl rule__EnumerationLiteralCS__Group__1 )
            // InternalQVTbase.g:6745:2: rule__EnumerationLiteralCS__Group__0__Impl rule__EnumerationLiteralCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_27);
            rule__EnumerationLiteralCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__0"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__0__Impl"
    // InternalQVTbase.g:6752:1: rule__EnumerationLiteralCS__Group__0__Impl : ( ( rule__EnumerationLiteralCS__Alternatives_0 ) ) ;
    public final void rule__EnumerationLiteralCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6756:1: ( ( ( rule__EnumerationLiteralCS__Alternatives_0 ) ) )
            // InternalQVTbase.g:6757:1: ( ( rule__EnumerationLiteralCS__Alternatives_0 ) )
            {
            // InternalQVTbase.g:6757:1: ( ( rule__EnumerationLiteralCS__Alternatives_0 ) )
            // InternalQVTbase.g:6758:1: ( rule__EnumerationLiteralCS__Alternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getAlternatives_0());
            }
            // InternalQVTbase.g:6759:1: ( rule__EnumerationLiteralCS__Alternatives_0 )
            // InternalQVTbase.g:6759:2: rule__EnumerationLiteralCS__Alternatives_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Alternatives_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__0__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__1"
    // InternalQVTbase.g:6769:1: rule__EnumerationLiteralCS__Group__1 : rule__EnumerationLiteralCS__Group__1__Impl rule__EnumerationLiteralCS__Group__2 ;
    public final void rule__EnumerationLiteralCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6773:1: ( rule__EnumerationLiteralCS__Group__1__Impl rule__EnumerationLiteralCS__Group__2 )
            // InternalQVTbase.g:6774:2: rule__EnumerationLiteralCS__Group__1__Impl rule__EnumerationLiteralCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_27);
            rule__EnumerationLiteralCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__1"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__1__Impl"
    // InternalQVTbase.g:6781:1: rule__EnumerationLiteralCS__Group__1__Impl : ( ( rule__EnumerationLiteralCS__Group_1__0 )? ) ;
    public final void rule__EnumerationLiteralCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6785:1: ( ( ( rule__EnumerationLiteralCS__Group_1__0 )? ) )
            // InternalQVTbase.g:6786:1: ( ( rule__EnumerationLiteralCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:6786:1: ( ( rule__EnumerationLiteralCS__Group_1__0 )? )
            // InternalQVTbase.g:6787:1: ( rule__EnumerationLiteralCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:6788:1: ( rule__EnumerationLiteralCS__Group_1__0 )?
            int alt82=2;
            int LA82_0 = input.LA(1);

            if ( (LA82_0==29) ) {
                alt82=1;
            }
            switch (alt82) {
                case 1 :
                    // InternalQVTbase.g:6788:2: rule__EnumerationLiteralCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__EnumerationLiteralCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__1__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__2"
    // InternalQVTbase.g:6798:1: rule__EnumerationLiteralCS__Group__2 : rule__EnumerationLiteralCS__Group__2__Impl ;
    public final void rule__EnumerationLiteralCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6802:1: ( rule__EnumerationLiteralCS__Group__2__Impl )
            // InternalQVTbase.g:6803:2: rule__EnumerationLiteralCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__2"


    // $ANTLR start "rule__EnumerationLiteralCS__Group__2__Impl"
    // InternalQVTbase.g:6809:1: rule__EnumerationLiteralCS__Group__2__Impl : ( ( rule__EnumerationLiteralCS__Alternatives_2 ) ) ;
    public final void rule__EnumerationLiteralCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6813:1: ( ( ( rule__EnumerationLiteralCS__Alternatives_2 ) ) )
            // InternalQVTbase.g:6814:1: ( ( rule__EnumerationLiteralCS__Alternatives_2 ) )
            {
            // InternalQVTbase.g:6814:1: ( ( rule__EnumerationLiteralCS__Alternatives_2 ) )
            // InternalQVTbase.g:6815:1: ( rule__EnumerationLiteralCS__Alternatives_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getAlternatives_2());
            }
            // InternalQVTbase.g:6816:1: ( rule__EnumerationLiteralCS__Alternatives_2 )
            // InternalQVTbase.g:6816:2: rule__EnumerationLiteralCS__Alternatives_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Alternatives_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getAlternatives_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group__2__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_0_0__0"
    // InternalQVTbase.g:6832:1: rule__EnumerationLiteralCS__Group_0_0__0 : rule__EnumerationLiteralCS__Group_0_0__0__Impl rule__EnumerationLiteralCS__Group_0_0__1 ;
    public final void rule__EnumerationLiteralCS__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6836:1: ( rule__EnumerationLiteralCS__Group_0_0__0__Impl rule__EnumerationLiteralCS__Group_0_0__1 )
            // InternalQVTbase.g:6837:2: rule__EnumerationLiteralCS__Group_0_0__0__Impl rule__EnumerationLiteralCS__Group_0_0__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__EnumerationLiteralCS__Group_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group_0_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_0_0__0"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_0_0__0__Impl"
    // InternalQVTbase.g:6844:1: rule__EnumerationLiteralCS__Group_0_0__0__Impl : ( 'literal' ) ;
    public final void rule__EnumerationLiteralCS__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6848:1: ( ( 'literal' ) )
            // InternalQVTbase.g:6849:1: ( 'literal' )
            {
            // InternalQVTbase.g:6849:1: ( 'literal' )
            // InternalQVTbase.g:6850:1: 'literal'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getLiteralKeyword_0_0_0());
            }
            match(input,69,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getLiteralKeyword_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_0_0__0__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_0_0__1"
    // InternalQVTbase.g:6863:1: rule__EnumerationLiteralCS__Group_0_0__1 : rule__EnumerationLiteralCS__Group_0_0__1__Impl ;
    public final void rule__EnumerationLiteralCS__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6867:1: ( rule__EnumerationLiteralCS__Group_0_0__1__Impl )
            // InternalQVTbase.g:6868:2: rule__EnumerationLiteralCS__Group_0_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group_0_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_0_0__1"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_0_0__1__Impl"
    // InternalQVTbase.g:6874:1: rule__EnumerationLiteralCS__Group_0_0__1__Impl : ( ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 ) ) ;
    public final void rule__EnumerationLiteralCS__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6878:1: ( ( ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 ) ) )
            // InternalQVTbase.g:6879:1: ( ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 ) )
            {
            // InternalQVTbase.g:6879:1: ( ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 ) )
            // InternalQVTbase.g:6880:1: ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getNameAssignment_0_0_1());
            }
            // InternalQVTbase.g:6881:1: ( rule__EnumerationLiteralCS__NameAssignment_0_0_1 )
            // InternalQVTbase.g:6881:2: rule__EnumerationLiteralCS__NameAssignment_0_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__NameAssignment_0_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getNameAssignment_0_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_0_0__1__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_1__0"
    // InternalQVTbase.g:6895:1: rule__EnumerationLiteralCS__Group_1__0 : rule__EnumerationLiteralCS__Group_1__0__Impl rule__EnumerationLiteralCS__Group_1__1 ;
    public final void rule__EnumerationLiteralCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6899:1: ( rule__EnumerationLiteralCS__Group_1__0__Impl rule__EnumerationLiteralCS__Group_1__1 )
            // InternalQVTbase.g:6900:2: rule__EnumerationLiteralCS__Group_1__0__Impl rule__EnumerationLiteralCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_28);
            rule__EnumerationLiteralCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_1__0"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_1__0__Impl"
    // InternalQVTbase.g:6907:1: rule__EnumerationLiteralCS__Group_1__0__Impl : ( '=' ) ;
    public final void rule__EnumerationLiteralCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6911:1: ( ( '=' ) )
            // InternalQVTbase.g:6912:1: ( '=' )
            {
            // InternalQVTbase.g:6912:1: ( '=' )
            // InternalQVTbase.g:6913:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getEqualsSignKeyword_1_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getEqualsSignKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_1__0__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_1__1"
    // InternalQVTbase.g:6926:1: rule__EnumerationLiteralCS__Group_1__1 : rule__EnumerationLiteralCS__Group_1__1__Impl ;
    public final void rule__EnumerationLiteralCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6930:1: ( rule__EnumerationLiteralCS__Group_1__1__Impl )
            // InternalQVTbase.g:6931:2: rule__EnumerationLiteralCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__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__EnumerationLiteralCS__Group_1__1"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_1__1__Impl"
    // InternalQVTbase.g:6937:1: rule__EnumerationLiteralCS__Group_1__1__Impl : ( ( rule__EnumerationLiteralCS__ValueAssignment_1_1 ) ) ;
    public final void rule__EnumerationLiteralCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6941:1: ( ( ( rule__EnumerationLiteralCS__ValueAssignment_1_1 ) ) )
            // InternalQVTbase.g:6942:1: ( ( rule__EnumerationLiteralCS__ValueAssignment_1_1 ) )
            {
            // InternalQVTbase.g:6942:1: ( ( rule__EnumerationLiteralCS__ValueAssignment_1_1 ) )
            // InternalQVTbase.g:6943:1: ( rule__EnumerationLiteralCS__ValueAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getValueAssignment_1_1());
            }
            // InternalQVTbase.g:6944:1: ( rule__EnumerationLiteralCS__ValueAssignment_1_1 )
            // InternalQVTbase.g:6944:2: rule__EnumerationLiteralCS__ValueAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__ValueAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getValueAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_1__1__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_2_0__0"
    // InternalQVTbase.g:6958:1: rule__EnumerationLiteralCS__Group_2_0__0 : rule__EnumerationLiteralCS__Group_2_0__0__Impl rule__EnumerationLiteralCS__Group_2_0__1 ;
    public final void rule__EnumerationLiteralCS__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6962:1: ( rule__EnumerationLiteralCS__Group_2_0__0__Impl rule__EnumerationLiteralCS__Group_2_0__1 )
            // InternalQVTbase.g:6963:2: rule__EnumerationLiteralCS__Group_2_0__0__Impl rule__EnumerationLiteralCS__Group_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__EnumerationLiteralCS__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_2_0__0"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_2_0__0__Impl"
    // InternalQVTbase.g:6970:1: rule__EnumerationLiteralCS__Group_2_0__0__Impl : ( '{' ) ;
    public final void rule__EnumerationLiteralCS__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6974:1: ( ( '{' ) )
            // InternalQVTbase.g:6975:1: ( '{' )
            {
            // InternalQVTbase.g:6975:1: ( '{' )
            // InternalQVTbase.g:6976:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getLeftCurlyBracketKeyword_2_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getLeftCurlyBracketKeyword_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_2_0__0__Impl"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_2_0__1"
    // InternalQVTbase.g:6989:1: rule__EnumerationLiteralCS__Group_2_0__1 : rule__EnumerationLiteralCS__Group_2_0__1__Impl ;
    public final void rule__EnumerationLiteralCS__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:6993:1: ( rule__EnumerationLiteralCS__Group_2_0__1__Impl )
            // InternalQVTbase.g:6994:2: rule__EnumerationLiteralCS__Group_2_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__EnumerationLiteralCS__Group_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_2_0__1"


    // $ANTLR start "rule__EnumerationLiteralCS__Group_2_0__1__Impl"
    // InternalQVTbase.g:7000:1: rule__EnumerationLiteralCS__Group_2_0__1__Impl : ( '}' ) ;
    public final void rule__EnumerationLiteralCS__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7004:1: ( ( '}' ) )
            // InternalQVTbase.g:7005:1: ( '}' )
            {
            // InternalQVTbase.g:7005:1: ( '}' )
            // InternalQVTbase.g:7006:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getRightCurlyBracketKeyword_2_0_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getRightCurlyBracketKeyword_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__Group_2_0__1__Impl"


    // $ANTLR start "rule__OperationCS__Group__0"
    // InternalQVTbase.g:7023: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 {
            // InternalQVTbase.g:7027:1: ( rule__OperationCS__Group__0__Impl rule__OperationCS__Group__1 )
            // InternalQVTbase.g:7028:2: rule__OperationCS__Group__0__Impl rule__OperationCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_29);
            rule__OperationCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7035:1: rule__OperationCS__Group__0__Impl : ( ( rule__OperationCS__Alternatives_0 )? ) ;
    public final void rule__OperationCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7039:1: ( ( ( rule__OperationCS__Alternatives_0 )? ) )
            // InternalQVTbase.g:7040:1: ( ( rule__OperationCS__Alternatives_0 )? )
            {
            // InternalQVTbase.g:7040:1: ( ( rule__OperationCS__Alternatives_0 )? )
            // InternalQVTbase.g:7041:1: ( rule__OperationCS__Alternatives_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getAlternatives_0());
            }
            // InternalQVTbase.g:7042:1: ( rule__OperationCS__Alternatives_0 )?
            int alt83=2;
            int LA83_0 = input.LA(1);

            if ( ((LA83_0>=99 && LA83_0<=100)) ) {
                alt83=1;
            }
            switch (alt83) {
                case 1 :
                    // InternalQVTbase.g:7042:2: rule__OperationCS__Alternatives_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Alternatives_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getAlternatives_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"
    // InternalQVTbase.g:7052: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 {
            // InternalQVTbase.g:7056:1: ( rule__OperationCS__Group__1__Impl rule__OperationCS__Group__2 )
            // InternalQVTbase.g:7057:2: rule__OperationCS__Group__1__Impl rule__OperationCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_30);
            rule__OperationCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7064:1: rule__OperationCS__Group__1__Impl : ( 'operation' ) ;
    public final void rule__OperationCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7068:1: ( ( 'operation' ) )
            // InternalQVTbase.g:7069:1: ( 'operation' )
            {
            // InternalQVTbase.g:7069:1: ( 'operation' )
            // InternalQVTbase.g:7070:1: 'operation'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOperationKeyword_1());
            }
            match(input,70,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOperationKeyword_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"
    // InternalQVTbase.g:7083: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 {
            // InternalQVTbase.g:7087:1: ( rule__OperationCS__Group__2__Impl rule__OperationCS__Group__3 )
            // InternalQVTbase.g:7088:2: rule__OperationCS__Group__2__Impl rule__OperationCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_30);
            rule__OperationCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7095:1: rule__OperationCS__Group__2__Impl : ( ( rule__OperationCS__OwnedSignatureAssignment_2 )? ) ;
    public final void rule__OperationCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7099:1: ( ( ( rule__OperationCS__OwnedSignatureAssignment_2 )? ) )
            // InternalQVTbase.g:7100:1: ( ( rule__OperationCS__OwnedSignatureAssignment_2 )? )
            {
            // InternalQVTbase.g:7100:1: ( ( rule__OperationCS__OwnedSignatureAssignment_2 )? )
            // InternalQVTbase.g:7101:1: ( rule__OperationCS__OwnedSignatureAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedSignatureAssignment_2());
            }
            // InternalQVTbase.g:7102:1: ( rule__OperationCS__OwnedSignatureAssignment_2 )?
            int alt84=2;
            int LA84_0 = input.LA(1);

            if ( (LA84_0==71) ) {
                alt84=1;
            }
            switch (alt84) {
                case 1 :
                    // InternalQVTbase.g:7102:2: rule__OperationCS__OwnedSignatureAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__OwnedSignatureAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedSignatureAssignment_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"
    // InternalQVTbase.g:7112: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 {
            // InternalQVTbase.g:7116:1: ( rule__OperationCS__Group__3__Impl rule__OperationCS__Group__4 )
            // InternalQVTbase.g:7117:2: rule__OperationCS__Group__3__Impl rule__OperationCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__OperationCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7124:1: rule__OperationCS__Group__3__Impl : ( ( rule__OperationCS__NameAssignment_3 ) ) ;
    public final void rule__OperationCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7128:1: ( ( ( rule__OperationCS__NameAssignment_3 ) ) )
            // InternalQVTbase.g:7129:1: ( ( rule__OperationCS__NameAssignment_3 ) )
            {
            // InternalQVTbase.g:7129:1: ( ( rule__OperationCS__NameAssignment_3 ) )
            // InternalQVTbase.g:7130:1: ( rule__OperationCS__NameAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getNameAssignment_3());
            }
            // InternalQVTbase.g:7131:1: ( rule__OperationCS__NameAssignment_3 )
            // InternalQVTbase.g:7131:2: rule__OperationCS__NameAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__NameAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getNameAssignment_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"
    // InternalQVTbase.g:7141: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 {
            // InternalQVTbase.g:7145:1: ( rule__OperationCS__Group__4__Impl rule__OperationCS__Group__5 )
            // InternalQVTbase.g:7146:2: rule__OperationCS__Group__4__Impl rule__OperationCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_32);
            rule__OperationCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7153:1: rule__OperationCS__Group__4__Impl : ( '(' ) ;
    public final void rule__OperationCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7157:1: ( ( '(' ) )
            // InternalQVTbase.g:7158:1: ( '(' )
            {
            // InternalQVTbase.g:7158:1: ( '(' )
            // InternalQVTbase.g:7159:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getLeftParenthesisKeyword_4());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getLeftParenthesisKeyword_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"
    // InternalQVTbase.g:7172: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 {
            // InternalQVTbase.g:7176:1: ( rule__OperationCS__Group__5__Impl rule__OperationCS__Group__6 )
            // InternalQVTbase.g:7177:2: rule__OperationCS__Group__5__Impl rule__OperationCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_32);
            rule__OperationCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7184:1: rule__OperationCS__Group__5__Impl : ( ( rule__OperationCS__Group_5__0 )? ) ;
    public final void rule__OperationCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7188:1: ( ( ( rule__OperationCS__Group_5__0 )? ) )
            // InternalQVTbase.g:7189:1: ( ( rule__OperationCS__Group_5__0 )? )
            {
            // InternalQVTbase.g:7189:1: ( ( rule__OperationCS__Group_5__0 )? )
            // InternalQVTbase.g:7190:1: ( rule__OperationCS__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_5());
            }
            // InternalQVTbase.g:7191:1: ( rule__OperationCS__Group_5__0 )?
            int alt85=2;
            int LA85_0 = input.LA(1);

            if ( ((LA85_0>=RULE_SIMPLE_ID && LA85_0<=RULE_ESCAPED_ID)) ) {
                alt85=1;
            }
            switch (alt85) {
                case 1 :
                    // InternalQVTbase.g:7191:2: rule__OperationCS__Group_5__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_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"
    // InternalQVTbase.g:7201: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 {
            // InternalQVTbase.g:7205:1: ( rule__OperationCS__Group__6__Impl rule__OperationCS__Group__7 )
            // InternalQVTbase.g:7206:2: rule__OperationCS__Group__6__Impl rule__OperationCS__Group__7
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__OperationCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7213:1: rule__OperationCS__Group__6__Impl : ( ')' ) ;
    public final void rule__OperationCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7217:1: ( ( ')' ) )
            // InternalQVTbase.g:7218:1: ( ')' )
            {
            // InternalQVTbase.g:7218:1: ( ')' )
            // InternalQVTbase.g:7219:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getRightParenthesisKeyword_6());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getRightParenthesisKeyword_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"
    // InternalQVTbase.g:7232: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 {
            // InternalQVTbase.g:7236:1: ( rule__OperationCS__Group__7__Impl rule__OperationCS__Group__8 )
            // InternalQVTbase.g:7237:2: rule__OperationCS__Group__7__Impl rule__OperationCS__Group__8
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__OperationCS__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7244:1: rule__OperationCS__Group__7__Impl : ( ( rule__OperationCS__Group_7__0 )? ) ;
    public final void rule__OperationCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7248:1: ( ( ( rule__OperationCS__Group_7__0 )? ) )
            // InternalQVTbase.g:7249:1: ( ( rule__OperationCS__Group_7__0 )? )
            {
            // InternalQVTbase.g:7249:1: ( ( rule__OperationCS__Group_7__0 )? )
            // InternalQVTbase.g:7250:1: ( rule__OperationCS__Group_7__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_7());
            }
            // InternalQVTbase.g:7251:1: ( rule__OperationCS__Group_7__0 )?
            int alt86=2;
            int LA86_0 = input.LA(1);

            if ( (LA86_0==61) ) {
                alt86=1;
            }
            switch (alt86) {
                case 1 :
                    // InternalQVTbase.g:7251:2: rule__OperationCS__Group_7__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_7__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_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"
    // InternalQVTbase.g:7261: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 {
            // InternalQVTbase.g:7265:1: ( rule__OperationCS__Group__8__Impl rule__OperationCS__Group__9 )
            // InternalQVTbase.g:7266:2: rule__OperationCS__Group__8__Impl rule__OperationCS__Group__9
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__OperationCS__Group__8__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:7273:1: rule__OperationCS__Group__8__Impl : ( ( rule__OperationCS__Group_8__0 )? ) ;
    public final void rule__OperationCS__Group__8__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7277:1: ( ( ( rule__OperationCS__Group_8__0 )? ) )
            // InternalQVTbase.g:7278:1: ( ( rule__OperationCS__Group_8__0 )? )
            {
            // InternalQVTbase.g:7278:1: ( ( rule__OperationCS__Group_8__0 )? )
            // InternalQVTbase.g:7279:1: ( rule__OperationCS__Group_8__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_8());
            }
            // InternalQVTbase.g:7280:1: ( rule__OperationCS__Group_8__0 )?
            int alt87=2;
            int LA87_0 = input.LA(1);

            if ( (LA87_0==73) ) {
                alt87=1;
            }
            switch (alt87) {
                case 1 :
                    // InternalQVTbase.g:7280:2: rule__OperationCS__Group_8__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_8__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_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"
    // InternalQVTbase.g:7290:1: rule__OperationCS__Group__9 : rule__OperationCS__Group__9__Impl rule__OperationCS__Group__10 ;
    public final void rule__OperationCS__Group__9() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7294:1: ( rule__OperationCS__Group__9__Impl rule__OperationCS__Group__10 )
            // InternalQVTbase.g:7295:2: rule__OperationCS__Group__9__Impl rule__OperationCS__Group__10
            {
            pushFollow(FollowSets000.FOLLOW_33);
            rule__OperationCS__Group__9__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group__10();

            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"
    // InternalQVTbase.g:7302:1: rule__OperationCS__Group__9__Impl : ( ( rule__OperationCS__Group_9__0 )? ) ;
    public final void rule__OperationCS__Group__9__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7306:1: ( ( ( rule__OperationCS__Group_9__0 )? ) )
            // InternalQVTbase.g:7307:1: ( ( rule__OperationCS__Group_9__0 )? )
            {
            // InternalQVTbase.g:7307:1: ( ( rule__OperationCS__Group_9__0 )? )
            // InternalQVTbase.g:7308:1: ( rule__OperationCS__Group_9__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_9());
            }
            // InternalQVTbase.g:7309:1: ( rule__OperationCS__Group_9__0 )?
            int alt88=2;
            int LA88_0 = input.LA(1);

            if ( (LA88_0==62) ) {
                int LA88_1 = input.LA(2);

                if ( ((LA88_1>=101 && LA88_1<=102)||(LA88_1>=105 && LA88_1<=106)||(LA88_1>=111 && LA88_1<=112)) ) {
                    alt88=1;
                }
            }
            switch (alt88) {
                case 1 :
                    // InternalQVTbase.g:7309:2: rule__OperationCS__Group_9__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__Group_9__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_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__10"
    // InternalQVTbase.g:7319:1: rule__OperationCS__Group__10 : rule__OperationCS__Group__10__Impl ;
    public final void rule__OperationCS__Group__10() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7323:1: ( rule__OperationCS__Group__10__Impl )
            // InternalQVTbase.g:7324:2: rule__OperationCS__Group__10__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group__10__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group__10"


    // $ANTLR start "rule__OperationCS__Group__10__Impl"
    // InternalQVTbase.g:7330:1: rule__OperationCS__Group__10__Impl : ( ( rule__OperationCS__Alternatives_10 ) ) ;
    public final void rule__OperationCS__Group__10__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7334:1: ( ( ( rule__OperationCS__Alternatives_10 ) ) )
            // InternalQVTbase.g:7335:1: ( ( rule__OperationCS__Alternatives_10 ) )
            {
            // InternalQVTbase.g:7335:1: ( ( rule__OperationCS__Alternatives_10 ) )
            // InternalQVTbase.g:7336:1: ( rule__OperationCS__Alternatives_10 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getAlternatives_10());
            }
            // InternalQVTbase.g:7337:1: ( rule__OperationCS__Alternatives_10 )
            // InternalQVTbase.g:7337:2: rule__OperationCS__Alternatives_10
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Alternatives_10();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getAlternatives_10());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group__10__Impl"


    // $ANTLR start "rule__OperationCS__Group_0_0__0"
    // InternalQVTbase.g:7369:1: rule__OperationCS__Group_0_0__0 : rule__OperationCS__Group_0_0__0__Impl rule__OperationCS__Group_0_0__1 ;
    public final void rule__OperationCS__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7373:1: ( rule__OperationCS__Group_0_0__0__Impl rule__OperationCS__Group_0_0__1 )
            // InternalQVTbase.g:7374:2: rule__OperationCS__Group_0_0__0__Impl rule__OperationCS__Group_0_0__1
            {
            pushFollow(FollowSets000.FOLLOW_7);
            rule__OperationCS__Group_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_0_0__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_0__0"


    // $ANTLR start "rule__OperationCS__Group_0_0__0__Impl"
    // InternalQVTbase.g:7381:1: rule__OperationCS__Group_0_0__0__Impl : ( ( rule__OperationCS__QualifiersAssignment_0_0_0 ) ) ;
    public final void rule__OperationCS__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7385:1: ( ( ( rule__OperationCS__QualifiersAssignment_0_0_0 ) ) )
            // InternalQVTbase.g:7386:1: ( ( rule__OperationCS__QualifiersAssignment_0_0_0 ) )
            {
            // InternalQVTbase.g:7386:1: ( ( rule__OperationCS__QualifiersAssignment_0_0_0 ) )
            // InternalQVTbase.g:7387:1: ( rule__OperationCS__QualifiersAssignment_0_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_0_0());
            }
            // InternalQVTbase.g:7388:1: ( rule__OperationCS__QualifiersAssignment_0_0_0 )
            // InternalQVTbase.g:7388:2: rule__OperationCS__QualifiersAssignment_0_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__QualifiersAssignment_0_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_0__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_0_0__1"
    // InternalQVTbase.g:7398:1: rule__OperationCS__Group_0_0__1 : rule__OperationCS__Group_0_0__1__Impl ;
    public final void rule__OperationCS__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7402:1: ( rule__OperationCS__Group_0_0__1__Impl )
            // InternalQVTbase.g:7403:2: rule__OperationCS__Group_0_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_0_0__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_0_0__1"


    // $ANTLR start "rule__OperationCS__Group_0_0__1__Impl"
    // InternalQVTbase.g:7409:1: rule__OperationCS__Group_0_0__1__Impl : ( ( rule__OperationCS__QualifiersAssignment_0_0_1 )? ) ;
    public final void rule__OperationCS__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7413:1: ( ( ( rule__OperationCS__QualifiersAssignment_0_0_1 )? ) )
            // InternalQVTbase.g:7414:1: ( ( rule__OperationCS__QualifiersAssignment_0_0_1 )? )
            {
            // InternalQVTbase.g:7414:1: ( ( rule__OperationCS__QualifiersAssignment_0_0_1 )? )
            // InternalQVTbase.g:7415:1: ( rule__OperationCS__QualifiersAssignment_0_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_0_1());
            }
            // InternalQVTbase.g:7416:1: ( rule__OperationCS__QualifiersAssignment_0_0_1 )?
            int alt89=2;
            int LA89_0 = input.LA(1);

            if ( (LA89_0==100) ) {
                alt89=1;
            }
            switch (alt89) {
                case 1 :
                    // InternalQVTbase.g:7416:2: rule__OperationCS__QualifiersAssignment_0_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_0_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_0__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_0_1__0"
    // InternalQVTbase.g:7430:1: rule__OperationCS__Group_0_1__0 : rule__OperationCS__Group_0_1__0__Impl rule__OperationCS__Group_0_1__1 ;
    public final void rule__OperationCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7434:1: ( rule__OperationCS__Group_0_1__0__Impl rule__OperationCS__Group_0_1__1 )
            // InternalQVTbase.g:7435:2: rule__OperationCS__Group_0_1__0__Impl rule__OperationCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__OperationCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_1__0"


    // $ANTLR start "rule__OperationCS__Group_0_1__0__Impl"
    // InternalQVTbase.g:7442:1: rule__OperationCS__Group_0_1__0__Impl : ( ( rule__OperationCS__QualifiersAssignment_0_1_0 ) ) ;
    public final void rule__OperationCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7446:1: ( ( ( rule__OperationCS__QualifiersAssignment_0_1_0 ) ) )
            // InternalQVTbase.g:7447:1: ( ( rule__OperationCS__QualifiersAssignment_0_1_0 ) )
            {
            // InternalQVTbase.g:7447:1: ( ( rule__OperationCS__QualifiersAssignment_0_1_0 ) )
            // InternalQVTbase.g:7448:1: ( rule__OperationCS__QualifiersAssignment_0_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_1_0());
            }
            // InternalQVTbase.g:7449:1: ( rule__OperationCS__QualifiersAssignment_0_1_0 )
            // InternalQVTbase.g:7449:2: rule__OperationCS__QualifiersAssignment_0_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__QualifiersAssignment_0_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_0_1__1"
    // InternalQVTbase.g:7459:1: rule__OperationCS__Group_0_1__1 : rule__OperationCS__Group_0_1__1__Impl ;
    public final void rule__OperationCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7463:1: ( rule__OperationCS__Group_0_1__1__Impl )
            // InternalQVTbase.g:7464:2: rule__OperationCS__Group_0_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_1__1"


    // $ANTLR start "rule__OperationCS__Group_0_1__1__Impl"
    // InternalQVTbase.g:7470:1: rule__OperationCS__Group_0_1__1__Impl : ( ( rule__OperationCS__QualifiersAssignment_0_1_1 )? ) ;
    public final void rule__OperationCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7474:1: ( ( ( rule__OperationCS__QualifiersAssignment_0_1_1 )? ) )
            // InternalQVTbase.g:7475:1: ( ( rule__OperationCS__QualifiersAssignment_0_1_1 )? )
            {
            // InternalQVTbase.g:7475:1: ( ( rule__OperationCS__QualifiersAssignment_0_1_1 )? )
            // InternalQVTbase.g:7476:1: ( rule__OperationCS__QualifiersAssignment_0_1_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_1_1());
            }
            // InternalQVTbase.g:7477:1: ( rule__OperationCS__QualifiersAssignment_0_1_1 )?
            int alt90=2;
            int LA90_0 = input.LA(1);

            if ( (LA90_0==99) ) {
                alt90=1;
            }
            switch (alt90) {
                case 1 :
                    // InternalQVTbase.g:7477:2: rule__OperationCS__QualifiersAssignment_0_1_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__QualifiersAssignment_0_1_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_5__0"
    // InternalQVTbase.g:7491:1: rule__OperationCS__Group_5__0 : rule__OperationCS__Group_5__0__Impl rule__OperationCS__Group_5__1 ;
    public final void rule__OperationCS__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7495:1: ( rule__OperationCS__Group_5__0__Impl rule__OperationCS__Group_5__1 )
            // InternalQVTbase.g:7496:2: rule__OperationCS__Group_5__0__Impl rule__OperationCS__Group_5__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__OperationCS__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_5__0"


    // $ANTLR start "rule__OperationCS__Group_5__0__Impl"
    // InternalQVTbase.g:7503:1: rule__OperationCS__Group_5__0__Impl : ( ( rule__OperationCS__OwnedParametersAssignment_5_0 ) ) ;
    public final void rule__OperationCS__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7507:1: ( ( ( rule__OperationCS__OwnedParametersAssignment_5_0 ) ) )
            // InternalQVTbase.g:7508:1: ( ( rule__OperationCS__OwnedParametersAssignment_5_0 ) )
            {
            // InternalQVTbase.g:7508:1: ( ( rule__OperationCS__OwnedParametersAssignment_5_0 ) )
            // InternalQVTbase.g:7509:1: ( rule__OperationCS__OwnedParametersAssignment_5_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedParametersAssignment_5_0());
            }
            // InternalQVTbase.g:7510:1: ( rule__OperationCS__OwnedParametersAssignment_5_0 )
            // InternalQVTbase.g:7510:2: rule__OperationCS__OwnedParametersAssignment_5_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__OwnedParametersAssignment_5_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedParametersAssignment_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_5__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_5__1"
    // InternalQVTbase.g:7520:1: rule__OperationCS__Group_5__1 : rule__OperationCS__Group_5__1__Impl ;
    public final void rule__OperationCS__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7524:1: ( rule__OperationCS__Group_5__1__Impl )
            // InternalQVTbase.g:7525:2: rule__OperationCS__Group_5__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_5__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_5__1"


    // $ANTLR start "rule__OperationCS__Group_5__1__Impl"
    // InternalQVTbase.g:7531:1: rule__OperationCS__Group_5__1__Impl : ( ( rule__OperationCS__Group_5_1__0 )* ) ;
    public final void rule__OperationCS__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7535:1: ( ( ( rule__OperationCS__Group_5_1__0 )* ) )
            // InternalQVTbase.g:7536:1: ( ( rule__OperationCS__Group_5_1__0 )* )
            {
            // InternalQVTbase.g:7536:1: ( ( rule__OperationCS__Group_5_1__0 )* )
            // InternalQVTbase.g:7537:1: ( rule__OperationCS__Group_5_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_5_1());
            }
            // InternalQVTbase.g:7538:1: ( rule__OperationCS__Group_5_1__0 )*
            loop91:
            do {
                int alt91=2;
                int LA91_0 = input.LA(1);

                if ( (LA91_0==64) ) {
                    alt91=1;
                }


                switch (alt91) {
            	case 1 :
            	    // InternalQVTbase.g:7538:2: rule__OperationCS__Group_5_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__OperationCS__Group_5_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop91;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_5_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_5__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_5_1__0"
    // InternalQVTbase.g:7552:1: rule__OperationCS__Group_5_1__0 : rule__OperationCS__Group_5_1__0__Impl rule__OperationCS__Group_5_1__1 ;
    public final void rule__OperationCS__Group_5_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7556:1: ( rule__OperationCS__Group_5_1__0__Impl rule__OperationCS__Group_5_1__1 )
            // InternalQVTbase.g:7557:2: rule__OperationCS__Group_5_1__0__Impl rule__OperationCS__Group_5_1__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__OperationCS__Group_5_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_5_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_5_1__0"


    // $ANTLR start "rule__OperationCS__Group_5_1__0__Impl"
    // InternalQVTbase.g:7564:1: rule__OperationCS__Group_5_1__0__Impl : ( ',' ) ;
    public final void rule__OperationCS__Group_5_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7568:1: ( ( ',' ) )
            // InternalQVTbase.g:7569:1: ( ',' )
            {
            // InternalQVTbase.g:7569:1: ( ',' )
            // InternalQVTbase.g:7570:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getCommaKeyword_5_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getCommaKeyword_5_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_5_1__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_5_1__1"
    // InternalQVTbase.g:7583:1: rule__OperationCS__Group_5_1__1 : rule__OperationCS__Group_5_1__1__Impl ;
    public final void rule__OperationCS__Group_5_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7587:1: ( rule__OperationCS__Group_5_1__1__Impl )
            // InternalQVTbase.g:7588:2: rule__OperationCS__Group_5_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_5_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_5_1__1"


    // $ANTLR start "rule__OperationCS__Group_5_1__1__Impl"
    // InternalQVTbase.g:7594:1: rule__OperationCS__Group_5_1__1__Impl : ( ( rule__OperationCS__OwnedParametersAssignment_5_1_1 ) ) ;
    public final void rule__OperationCS__Group_5_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7598:1: ( ( ( rule__OperationCS__OwnedParametersAssignment_5_1_1 ) ) )
            // InternalQVTbase.g:7599:1: ( ( rule__OperationCS__OwnedParametersAssignment_5_1_1 ) )
            {
            // InternalQVTbase.g:7599:1: ( ( rule__OperationCS__OwnedParametersAssignment_5_1_1 ) )
            // InternalQVTbase.g:7600:1: ( rule__OperationCS__OwnedParametersAssignment_5_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedParametersAssignment_5_1_1());
            }
            // InternalQVTbase.g:7601:1: ( rule__OperationCS__OwnedParametersAssignment_5_1_1 )
            // InternalQVTbase.g:7601:2: rule__OperationCS__OwnedParametersAssignment_5_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__OwnedParametersAssignment_5_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedParametersAssignment_5_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_5_1__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_7__0"
    // InternalQVTbase.g:7615:1: rule__OperationCS__Group_7__0 : rule__OperationCS__Group_7__0__Impl rule__OperationCS__Group_7__1 ;
    public final void rule__OperationCS__Group_7__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7619:1: ( rule__OperationCS__Group_7__0__Impl rule__OperationCS__Group_7__1 )
            // InternalQVTbase.g:7620:2: rule__OperationCS__Group_7__0__Impl rule__OperationCS__Group_7__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__OperationCS__Group_7__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_7__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_7__0"


    // $ANTLR start "rule__OperationCS__Group_7__0__Impl"
    // InternalQVTbase.g:7627:1: rule__OperationCS__Group_7__0__Impl : ( ':' ) ;
    public final void rule__OperationCS__Group_7__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7631:1: ( ( ':' ) )
            // InternalQVTbase.g:7632:1: ( ':' )
            {
            // InternalQVTbase.g:7632:1: ( ':' )
            // InternalQVTbase.g:7633:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getColonKeyword_7_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getColonKeyword_7_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_7__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_7__1"
    // InternalQVTbase.g:7646:1: rule__OperationCS__Group_7__1 : rule__OperationCS__Group_7__1__Impl ;
    public final void rule__OperationCS__Group_7__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7650:1: ( rule__OperationCS__Group_7__1__Impl )
            // InternalQVTbase.g:7651:2: rule__OperationCS__Group_7__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_7__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_7__1"


    // $ANTLR start "rule__OperationCS__Group_7__1__Impl"
    // InternalQVTbase.g:7657:1: rule__OperationCS__Group_7__1__Impl : ( ( rule__OperationCS__OwnedTypeAssignment_7_1 ) ) ;
    public final void rule__OperationCS__Group_7__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7661:1: ( ( ( rule__OperationCS__OwnedTypeAssignment_7_1 ) ) )
            // InternalQVTbase.g:7662:1: ( ( rule__OperationCS__OwnedTypeAssignment_7_1 ) )
            {
            // InternalQVTbase.g:7662:1: ( ( rule__OperationCS__OwnedTypeAssignment_7_1 ) )
            // InternalQVTbase.g:7663:1: ( rule__OperationCS__OwnedTypeAssignment_7_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedTypeAssignment_7_1());
            }
            // InternalQVTbase.g:7664:1: ( rule__OperationCS__OwnedTypeAssignment_7_1 )
            // InternalQVTbase.g:7664:2: rule__OperationCS__OwnedTypeAssignment_7_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__OwnedTypeAssignment_7_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedTypeAssignment_7_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_7__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_8__0"
    // InternalQVTbase.g:7678:1: rule__OperationCS__Group_8__0 : rule__OperationCS__Group_8__0__Impl rule__OperationCS__Group_8__1 ;
    public final void rule__OperationCS__Group_8__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7682:1: ( rule__OperationCS__Group_8__0__Impl rule__OperationCS__Group_8__1 )
            // InternalQVTbase.g:7683:2: rule__OperationCS__Group_8__0__Impl rule__OperationCS__Group_8__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__OperationCS__Group_8__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_8__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__0"


    // $ANTLR start "rule__OperationCS__Group_8__0__Impl"
    // InternalQVTbase.g:7690:1: rule__OperationCS__Group_8__0__Impl : ( 'throws' ) ;
    public final void rule__OperationCS__Group_8__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7694:1: ( ( 'throws' ) )
            // InternalQVTbase.g:7695:1: ( 'throws' )
            {
            // InternalQVTbase.g:7695:1: ( 'throws' )
            // InternalQVTbase.g:7696:1: 'throws'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getThrowsKeyword_8_0());
            }
            match(input,73,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getThrowsKeyword_8_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_8__1"
    // InternalQVTbase.g:7709:1: rule__OperationCS__Group_8__1 : rule__OperationCS__Group_8__1__Impl rule__OperationCS__Group_8__2 ;
    public final void rule__OperationCS__Group_8__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7713:1: ( rule__OperationCS__Group_8__1__Impl rule__OperationCS__Group_8__2 )
            // InternalQVTbase.g:7714:2: rule__OperationCS__Group_8__1__Impl rule__OperationCS__Group_8__2
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__OperationCS__Group_8__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_8__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__1"


    // $ANTLR start "rule__OperationCS__Group_8__1__Impl"
    // InternalQVTbase.g:7721:1: rule__OperationCS__Group_8__1__Impl : ( ( rule__OperationCS__OwnedExceptionsAssignment_8_1 ) ) ;
    public final void rule__OperationCS__Group_8__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7725:1: ( ( ( rule__OperationCS__OwnedExceptionsAssignment_8_1 ) ) )
            // InternalQVTbase.g:7726:1: ( ( rule__OperationCS__OwnedExceptionsAssignment_8_1 ) )
            {
            // InternalQVTbase.g:7726:1: ( ( rule__OperationCS__OwnedExceptionsAssignment_8_1 ) )
            // InternalQVTbase.g:7727:1: ( rule__OperationCS__OwnedExceptionsAssignment_8_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedExceptionsAssignment_8_1());
            }
            // InternalQVTbase.g:7728:1: ( rule__OperationCS__OwnedExceptionsAssignment_8_1 )
            // InternalQVTbase.g:7728:2: rule__OperationCS__OwnedExceptionsAssignment_8_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__OwnedExceptionsAssignment_8_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedExceptionsAssignment_8_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_8__2"
    // InternalQVTbase.g:7738:1: rule__OperationCS__Group_8__2 : rule__OperationCS__Group_8__2__Impl ;
    public final void rule__OperationCS__Group_8__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7742:1: ( rule__OperationCS__Group_8__2__Impl )
            // InternalQVTbase.g:7743:2: rule__OperationCS__Group_8__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_8__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__2"


    // $ANTLR start "rule__OperationCS__Group_8__2__Impl"
    // InternalQVTbase.g:7749:1: rule__OperationCS__Group_8__2__Impl : ( ( rule__OperationCS__Group_8_2__0 )* ) ;
    public final void rule__OperationCS__Group_8__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7753:1: ( ( ( rule__OperationCS__Group_8_2__0 )* ) )
            // InternalQVTbase.g:7754:1: ( ( rule__OperationCS__Group_8_2__0 )* )
            {
            // InternalQVTbase.g:7754:1: ( ( rule__OperationCS__Group_8_2__0 )* )
            // InternalQVTbase.g:7755:1: ( rule__OperationCS__Group_8_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_8_2());
            }
            // InternalQVTbase.g:7756:1: ( rule__OperationCS__Group_8_2__0 )*
            loop92:
            do {
                int alt92=2;
                int LA92_0 = input.LA(1);

                if ( (LA92_0==64) ) {
                    alt92=1;
                }


                switch (alt92) {
            	case 1 :
            	    // InternalQVTbase.g:7756:2: rule__OperationCS__Group_8_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__OperationCS__Group_8_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop92;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_8_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8__2__Impl"


    // $ANTLR start "rule__OperationCS__Group_8_2__0"
    // InternalQVTbase.g:7772:1: rule__OperationCS__Group_8_2__0 : rule__OperationCS__Group_8_2__0__Impl rule__OperationCS__Group_8_2__1 ;
    public final void rule__OperationCS__Group_8_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7776:1: ( rule__OperationCS__Group_8_2__0__Impl rule__OperationCS__Group_8_2__1 )
            // InternalQVTbase.g:7777:2: rule__OperationCS__Group_8_2__0__Impl rule__OperationCS__Group_8_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__OperationCS__Group_8_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_8_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8_2__0"


    // $ANTLR start "rule__OperationCS__Group_8_2__0__Impl"
    // InternalQVTbase.g:7784:1: rule__OperationCS__Group_8_2__0__Impl : ( ',' ) ;
    public final void rule__OperationCS__Group_8_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7788:1: ( ( ',' ) )
            // InternalQVTbase.g:7789:1: ( ',' )
            {
            // InternalQVTbase.g:7789:1: ( ',' )
            // InternalQVTbase.g:7790:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getCommaKeyword_8_2_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getCommaKeyword_8_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8_2__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_8_2__1"
    // InternalQVTbase.g:7803:1: rule__OperationCS__Group_8_2__1 : rule__OperationCS__Group_8_2__1__Impl ;
    public final void rule__OperationCS__Group_8_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7807:1: ( rule__OperationCS__Group_8_2__1__Impl )
            // InternalQVTbase.g:7808:2: rule__OperationCS__Group_8_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_8_2__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_8_2__1"


    // $ANTLR start "rule__OperationCS__Group_8_2__1__Impl"
    // InternalQVTbase.g:7814:1: rule__OperationCS__Group_8_2__1__Impl : ( ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 ) ) ;
    public final void rule__OperationCS__Group_8_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7818:1: ( ( ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 ) ) )
            // InternalQVTbase.g:7819:1: ( ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 ) )
            {
            // InternalQVTbase.g:7819:1: ( ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 ) )
            // InternalQVTbase.g:7820:1: ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedExceptionsAssignment_8_2_1());
            }
            // InternalQVTbase.g:7821:1: ( rule__OperationCS__OwnedExceptionsAssignment_8_2_1 )
            // InternalQVTbase.g:7821:2: rule__OperationCS__OwnedExceptionsAssignment_8_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__OwnedExceptionsAssignment_8_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedExceptionsAssignment_8_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_8_2__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_9__0"
    // InternalQVTbase.g:7835:1: rule__OperationCS__Group_9__0 : rule__OperationCS__Group_9__0__Impl rule__OperationCS__Group_9__1 ;
    public final void rule__OperationCS__Group_9__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7839:1: ( rule__OperationCS__Group_9__0__Impl rule__OperationCS__Group_9__1 )
            // InternalQVTbase.g:7840:2: rule__OperationCS__Group_9__0__Impl rule__OperationCS__Group_9__1
            {
            pushFollow(FollowSets000.FOLLOW_35);
            rule__OperationCS__Group_9__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_9__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9__0"


    // $ANTLR start "rule__OperationCS__Group_9__0__Impl"
    // InternalQVTbase.g:7847:1: rule__OperationCS__Group_9__0__Impl : ( '{' ) ;
    public final void rule__OperationCS__Group_9__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7851:1: ( ( '{' ) )
            // InternalQVTbase.g:7852:1: ( '{' )
            {
            // InternalQVTbase.g:7852:1: ( '{' )
            // InternalQVTbase.g:7853:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getLeftCurlyBracketKeyword_9_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getLeftCurlyBracketKeyword_9_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_9__1"
    // InternalQVTbase.g:7866:1: rule__OperationCS__Group_9__1 : rule__OperationCS__Group_9__1__Impl rule__OperationCS__Group_9__2 ;
    public final void rule__OperationCS__Group_9__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7870:1: ( rule__OperationCS__Group_9__1__Impl rule__OperationCS__Group_9__2 )
            // InternalQVTbase.g:7871:2: rule__OperationCS__Group_9__1__Impl rule__OperationCS__Group_9__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__OperationCS__Group_9__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_9__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9__1"


    // $ANTLR start "rule__OperationCS__Group_9__1__Impl"
    // InternalQVTbase.g:7878:1: rule__OperationCS__Group_9__1__Impl : ( ( ( rule__OperationCS__Group_9_1__0 ) ) ( ( rule__OperationCS__Group_9_1__0 )* ) ) ;
    public final void rule__OperationCS__Group_9__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7882:1: ( ( ( ( rule__OperationCS__Group_9_1__0 ) ) ( ( rule__OperationCS__Group_9_1__0 )* ) ) )
            // InternalQVTbase.g:7883:1: ( ( ( rule__OperationCS__Group_9_1__0 ) ) ( ( rule__OperationCS__Group_9_1__0 )* ) )
            {
            // InternalQVTbase.g:7883:1: ( ( ( rule__OperationCS__Group_9_1__0 ) ) ( ( rule__OperationCS__Group_9_1__0 )* ) )
            // InternalQVTbase.g:7884:1: ( ( rule__OperationCS__Group_9_1__0 ) ) ( ( rule__OperationCS__Group_9_1__0 )* )
            {
            // InternalQVTbase.g:7884:1: ( ( rule__OperationCS__Group_9_1__0 ) )
            // InternalQVTbase.g:7885:1: ( rule__OperationCS__Group_9_1__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_9_1());
            }
            // InternalQVTbase.g:7886:1: ( rule__OperationCS__Group_9_1__0 )
            // InternalQVTbase.g:7886:2: rule__OperationCS__Group_9_1__0
            {
            pushFollow(FollowSets000.FOLLOW_36);
            rule__OperationCS__Group_9_1__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_9_1());
            }

            }

            // InternalQVTbase.g:7889:1: ( ( rule__OperationCS__Group_9_1__0 )* )
            // InternalQVTbase.g:7890:1: ( rule__OperationCS__Group_9_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_9_1());
            }
            // InternalQVTbase.g:7891:1: ( rule__OperationCS__Group_9_1__0 )*
            loop93:
            do {
                int alt93=2;
                int LA93_0 = input.LA(1);

                if ( ((LA93_0>=101 && LA93_0<=102)||(LA93_0>=105 && LA93_0<=106)||(LA93_0>=111 && LA93_0<=112)) ) {
                    alt93=1;
                }


                switch (alt93) {
            	case 1 :
            	    // InternalQVTbase.g:7891:2: rule__OperationCS__Group_9_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_36);
            	    rule__OperationCS__Group_9_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop93;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_9_1());
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_9__2"
    // InternalQVTbase.g:7902:1: rule__OperationCS__Group_9__2 : rule__OperationCS__Group_9__2__Impl ;
    public final void rule__OperationCS__Group_9__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7906:1: ( rule__OperationCS__Group_9__2__Impl )
            // InternalQVTbase.g:7907:2: rule__OperationCS__Group_9__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_9__2__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__2"


    // $ANTLR start "rule__OperationCS__Group_9__2__Impl"
    // InternalQVTbase.g:7913:1: rule__OperationCS__Group_9__2__Impl : ( '}' ) ;
    public final void rule__OperationCS__Group_9__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7917:1: ( ( '}' ) )
            // InternalQVTbase.g:7918:1: ( '}' )
            {
            // InternalQVTbase.g:7918:1: ( '}' )
            // InternalQVTbase.g:7919:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getRightCurlyBracketKeyword_9_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getRightCurlyBracketKeyword_9_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9__2__Impl"


    // $ANTLR start "rule__OperationCS__Group_9_1__0"
    // InternalQVTbase.g:7938:1: rule__OperationCS__Group_9_1__0 : rule__OperationCS__Group_9_1__0__Impl rule__OperationCS__Group_9_1__1 ;
    public final void rule__OperationCS__Group_9_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7942:1: ( rule__OperationCS__Group_9_1__0__Impl rule__OperationCS__Group_9_1__1 )
            // InternalQVTbase.g:7943:2: rule__OperationCS__Group_9_1__0__Impl rule__OperationCS__Group_9_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__OperationCS__Group_9_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_9_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_9_1__0"


    // $ANTLR start "rule__OperationCS__Group_9_1__0__Impl"
    // InternalQVTbase.g:7950:1: rule__OperationCS__Group_9_1__0__Impl : ( ( rule__OperationCS__Alternatives_9_1_0 ) ) ;
    public final void rule__OperationCS__Group_9_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7954:1: ( ( ( rule__OperationCS__Alternatives_9_1_0 ) ) )
            // InternalQVTbase.g:7955:1: ( ( rule__OperationCS__Alternatives_9_1_0 ) )
            {
            // InternalQVTbase.g:7955:1: ( ( rule__OperationCS__Alternatives_9_1_0 ) )
            // InternalQVTbase.g:7956:1: ( rule__OperationCS__Alternatives_9_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getAlternatives_9_1_0());
            }
            // InternalQVTbase.g:7957:1: ( rule__OperationCS__Alternatives_9_1_0 )
            // InternalQVTbase.g:7957:2: rule__OperationCS__Alternatives_9_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Alternatives_9_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getAlternatives_9_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9_1__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_9_1__1"
    // InternalQVTbase.g:7967:1: rule__OperationCS__Group_9_1__1 : rule__OperationCS__Group_9_1__1__Impl ;
    public final void rule__OperationCS__Group_9_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7971:1: ( rule__OperationCS__Group_9_1__1__Impl )
            // InternalQVTbase.g:7972:2: rule__OperationCS__Group_9_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_9_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_9_1__1"


    // $ANTLR start "rule__OperationCS__Group_9_1__1__Impl"
    // InternalQVTbase.g:7978:1: rule__OperationCS__Group_9_1__1__Impl : ( ( ',' )? ) ;
    public final void rule__OperationCS__Group_9_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:7982:1: ( ( ( ',' )? ) )
            // InternalQVTbase.g:7983:1: ( ( ',' )? )
            {
            // InternalQVTbase.g:7983:1: ( ( ',' )? )
            // InternalQVTbase.g:7984:1: ( ',' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getCommaKeyword_9_1_1());
            }
            // InternalQVTbase.g:7985:1: ( ',' )?
            int alt94=2;
            int LA94_0 = input.LA(1);

            if ( (LA94_0==64) ) {
                alt94=1;
            }
            switch (alt94) {
                case 1 :
                    // InternalQVTbase.g:7986:2: ','
                    {
                    match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getCommaKeyword_9_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_9_1__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0__0"
    // InternalQVTbase.g:8001:1: rule__OperationCS__Group_10_0__0 : rule__OperationCS__Group_10_0__0__Impl rule__OperationCS__Group_10_0__1 ;
    public final void rule__OperationCS__Group_10_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8005:1: ( rule__OperationCS__Group_10_0__0__Impl rule__OperationCS__Group_10_0__1 )
            // InternalQVTbase.g:8006:2: rule__OperationCS__Group_10_0__0__Impl rule__OperationCS__Group_10_0__1
            {
            pushFollow(FollowSets000.FOLLOW_37);
            rule__OperationCS__Group_10_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__0"


    // $ANTLR start "rule__OperationCS__Group_10_0__0__Impl"
    // InternalQVTbase.g:8013:1: rule__OperationCS__Group_10_0__0__Impl : ( '{' ) ;
    public final void rule__OperationCS__Group_10_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8017:1: ( ( '{' ) )
            // InternalQVTbase.g:8018:1: ( '{' )
            {
            // InternalQVTbase.g:8018:1: ( '{' )
            // InternalQVTbase.g:8019:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getLeftCurlyBracketKeyword_10_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getLeftCurlyBracketKeyword_10_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0__1"
    // InternalQVTbase.g:8032:1: rule__OperationCS__Group_10_0__1 : rule__OperationCS__Group_10_0__1__Impl rule__OperationCS__Group_10_0__2 ;
    public final void rule__OperationCS__Group_10_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8036:1: ( rule__OperationCS__Group_10_0__1__Impl rule__OperationCS__Group_10_0__2 )
            // InternalQVTbase.g:8037:2: rule__OperationCS__Group_10_0__1__Impl rule__OperationCS__Group_10_0__2
            {
            pushFollow(FollowSets000.FOLLOW_37);
            rule__OperationCS__Group_10_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__1"


    // $ANTLR start "rule__OperationCS__Group_10_0__1__Impl"
    // InternalQVTbase.g:8044:1: rule__OperationCS__Group_10_0__1__Impl : ( ( rule__OperationCS__Group_10_0_1__0 )* ) ;
    public final void rule__OperationCS__Group_10_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8048:1: ( ( ( rule__OperationCS__Group_10_0_1__0 )* ) )
            // InternalQVTbase.g:8049:1: ( ( rule__OperationCS__Group_10_0_1__0 )* )
            {
            // InternalQVTbase.g:8049:1: ( ( rule__OperationCS__Group_10_0_1__0 )* )
            // InternalQVTbase.g:8050:1: ( rule__OperationCS__Group_10_0_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getGroup_10_0_1());
            }
            // InternalQVTbase.g:8051:1: ( rule__OperationCS__Group_10_0_1__0 )*
            loop95:
            do {
                int alt95=2;
                int LA95_0 = input.LA(1);

                if ( (LA95_0==74) ) {
                    alt95=1;
                }


                switch (alt95) {
            	case 1 :
            	    // InternalQVTbase.g:8051:2: rule__OperationCS__Group_10_0_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_38);
            	    rule__OperationCS__Group_10_0_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop95;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getGroup_10_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0__2"
    // InternalQVTbase.g:8061:1: rule__OperationCS__Group_10_0__2 : rule__OperationCS__Group_10_0__2__Impl ;
    public final void rule__OperationCS__Group_10_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8065:1: ( rule__OperationCS__Group_10_0__2__Impl )
            // InternalQVTbase.g:8066:2: rule__OperationCS__Group_10_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__2"


    // $ANTLR start "rule__OperationCS__Group_10_0__2__Impl"
    // InternalQVTbase.g:8072:1: rule__OperationCS__Group_10_0__2__Impl : ( '}' ) ;
    public final void rule__OperationCS__Group_10_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8076:1: ( ( '}' ) )
            // InternalQVTbase.g:8077:1: ( '}' )
            {
            // InternalQVTbase.g:8077:1: ( '}' )
            // InternalQVTbase.g:8078:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getRightCurlyBracketKeyword_10_0_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getRightCurlyBracketKeyword_10_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0__2__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__0"
    // InternalQVTbase.g:8097:1: rule__OperationCS__Group_10_0_1__0 : rule__OperationCS__Group_10_0_1__0__Impl rule__OperationCS__Group_10_0_1__1 ;
    public final void rule__OperationCS__Group_10_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8101:1: ( rule__OperationCS__Group_10_0_1__0__Impl rule__OperationCS__Group_10_0_1__1 )
            // InternalQVTbase.g:8102:2: rule__OperationCS__Group_10_0_1__0__Impl rule__OperationCS__Group_10_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__OperationCS__Group_10_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0_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_10_0_1__0"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__0__Impl"
    // InternalQVTbase.g:8109:1: rule__OperationCS__Group_10_0_1__0__Impl : ( 'body' ) ;
    public final void rule__OperationCS__Group_10_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8113:1: ( ( 'body' ) )
            // InternalQVTbase.g:8114:1: ( 'body' )
            {
            // InternalQVTbase.g:8114:1: ( 'body' )
            // InternalQVTbase.g:8115:1: 'body'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getBodyKeyword_10_0_1_0());
            }
            match(input,74,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getBodyKeyword_10_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__0__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__1"
    // InternalQVTbase.g:8128:1: rule__OperationCS__Group_10_0_1__1 : rule__OperationCS__Group_10_0_1__1__Impl rule__OperationCS__Group_10_0_1__2 ;
    public final void rule__OperationCS__Group_10_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8132:1: ( rule__OperationCS__Group_10_0_1__1__Impl rule__OperationCS__Group_10_0_1__2 )
            // InternalQVTbase.g:8133:2: rule__OperationCS__Group_10_0_1__1__Impl rule__OperationCS__Group_10_0_1__2
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__OperationCS__Group_10_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__1"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__1__Impl"
    // InternalQVTbase.g:8140:1: rule__OperationCS__Group_10_0_1__1__Impl : ( ( ruleUnrestrictedName )? ) ;
    public final void rule__OperationCS__Group_10_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8144:1: ( ( ( ruleUnrestrictedName )? ) )
            // InternalQVTbase.g:8145:1: ( ( ruleUnrestrictedName )? )
            {
            // InternalQVTbase.g:8145:1: ( ( ruleUnrestrictedName )? )
            // InternalQVTbase.g:8146:1: ( ruleUnrestrictedName )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getUnrestrictedNameParserRuleCall_10_0_1_1());
            }
            // InternalQVTbase.g:8147:1: ( ruleUnrestrictedName )?
            int alt96=2;
            int LA96_0 = input.LA(1);

            if ( ((LA96_0>=RULE_SIMPLE_ID && LA96_0<=RULE_ESCAPED_ID)) ) {
                alt96=1;
            }
            switch (alt96) {
                case 1 :
                    // InternalQVTbase.g:8147:3: ruleUnrestrictedName
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getUnrestrictedNameParserRuleCall_10_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__1__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__2"
    // InternalQVTbase.g:8157:1: rule__OperationCS__Group_10_0_1__2 : rule__OperationCS__Group_10_0_1__2__Impl rule__OperationCS__Group_10_0_1__3 ;
    public final void rule__OperationCS__Group_10_0_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8161:1: ( rule__OperationCS__Group_10_0_1__2__Impl rule__OperationCS__Group_10_0_1__3 )
            // InternalQVTbase.g:8162:2: rule__OperationCS__Group_10_0_1__2__Impl rule__OperationCS__Group_10_0_1__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__OperationCS__Group_10_0_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__2"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__2__Impl"
    // InternalQVTbase.g:8169:1: rule__OperationCS__Group_10_0_1__2__Impl : ( ':' ) ;
    public final void rule__OperationCS__Group_10_0_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8173:1: ( ( ':' ) )
            // InternalQVTbase.g:8174:1: ( ':' )
            {
            // InternalQVTbase.g:8174:1: ( ':' )
            // InternalQVTbase.g:8175:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getColonKeyword_10_0_1_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getColonKeyword_10_0_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__2__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__3"
    // InternalQVTbase.g:8188:1: rule__OperationCS__Group_10_0_1__3 : rule__OperationCS__Group_10_0_1__3__Impl rule__OperationCS__Group_10_0_1__4 ;
    public final void rule__OperationCS__Group_10_0_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8192:1: ( rule__OperationCS__Group_10_0_1__3__Impl rule__OperationCS__Group_10_0_1__4 )
            // InternalQVTbase.g:8193:2: rule__OperationCS__Group_10_0_1__3__Impl rule__OperationCS__Group_10_0_1__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__OperationCS__Group_10_0_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0_1__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__3"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__3__Impl"
    // InternalQVTbase.g:8200:1: rule__OperationCS__Group_10_0_1__3__Impl : ( ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )? ) ;
    public final void rule__OperationCS__Group_10_0_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8204:1: ( ( ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )? ) )
            // InternalQVTbase.g:8205:1: ( ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )? )
            {
            // InternalQVTbase.g:8205:1: ( ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )? )
            // InternalQVTbase.g:8206:1: ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedBodyExpressionsAssignment_10_0_1_3());
            }
            // InternalQVTbase.g:8207:1: ( rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 )?
            int alt97=2;
            int LA97_0 = input.LA(1);

            if ( ((LA97_0>=RULE_INT && LA97_0<=RULE_UNQUOTED_STRING)||(LA97_0>=19 && LA97_0<=22)||(LA97_0>=43 && LA97_0<=57)||LA97_0==71||LA97_0==82||(LA97_0>=84 && LA97_0<=85)||LA97_0==90||(LA97_0>=95 && LA97_0<=96)||(LA97_0>=128 && LA97_0<=129)) ) {
                alt97=1;
            }
            switch (alt97) {
                case 1 :
                    // InternalQVTbase.g:8207:2: rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedBodyExpressionsAssignment_10_0_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__3__Impl"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__4"
    // InternalQVTbase.g:8217:1: rule__OperationCS__Group_10_0_1__4 : rule__OperationCS__Group_10_0_1__4__Impl ;
    public final void rule__OperationCS__Group_10_0_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8221:1: ( rule__OperationCS__Group_10_0_1__4__Impl )
            // InternalQVTbase.g:8222:2: rule__OperationCS__Group_10_0_1__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__OperationCS__Group_10_0_1__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__4"


    // $ANTLR start "rule__OperationCS__Group_10_0_1__4__Impl"
    // InternalQVTbase.g:8228:1: rule__OperationCS__Group_10_0_1__4__Impl : ( ';' ) ;
    public final void rule__OperationCS__Group_10_0_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8232:1: ( ( ';' ) )
            // InternalQVTbase.g:8233:1: ( ';' )
            {
            // InternalQVTbase.g:8233:1: ( ';' )
            // InternalQVTbase.g:8234:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getSemicolonKeyword_10_0_1_4());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getSemicolonKeyword_10_0_1_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__Group_10_0_1__4__Impl"


    // $ANTLR start "rule__ParameterCS__Group__0"
    // InternalQVTbase.g:8257: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 {
            // InternalQVTbase.g:8261:1: ( rule__ParameterCS__Group__0__Impl rule__ParameterCS__Group__1 )
            // InternalQVTbase.g:8262:2: rule__ParameterCS__Group__0__Impl rule__ParameterCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_39);
            rule__ParameterCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:8269:1: rule__ParameterCS__Group__0__Impl : ( ( rule__ParameterCS__NameAssignment_0 ) ) ;
    public final void rule__ParameterCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8273:1: ( ( ( rule__ParameterCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:8274:1: ( ( rule__ParameterCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:8274:1: ( ( rule__ParameterCS__NameAssignment_0 ) )
            // InternalQVTbase.g:8275:1: ( rule__ParameterCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:8276:1: ( rule__ParameterCS__NameAssignment_0 )
            // InternalQVTbase.g:8276:2: rule__ParameterCS__NameAssignment_0
            {
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:8286: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 {
            // InternalQVTbase.g:8290:1: ( rule__ParameterCS__Group__1__Impl rule__ParameterCS__Group__2 )
            // InternalQVTbase.g:8291:2: rule__ParameterCS__Group__1__Impl rule__ParameterCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_39);
            rule__ParameterCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.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"
    // InternalQVTbase.g:8298:1: rule__ParameterCS__Group__1__Impl : ( ( rule__ParameterCS__Group_1__0 )? ) ;
    public final void rule__ParameterCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8302:1: ( ( ( rule__ParameterCS__Group_1__0 )? ) )
            // InternalQVTbase.g:8303:1: ( ( rule__ParameterCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:8303:1: ( ( rule__ParameterCS__Group_1__0 )? )
            // InternalQVTbase.g:8304:1: ( rule__ParameterCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:8305:1: ( rule__ParameterCS__Group_1__0 )?
            int alt98=2;
            int LA98_0 = input.LA(1);

            if ( (LA98_0==61) ) {
                alt98=1;
            }
            switch (alt98) {
                case 1 :
                    // InternalQVTbase.g:8305:2: rule__ParameterCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getGroup_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"
    // InternalQVTbase.g:8315:1: rule__ParameterCS__Group__2 : rule__ParameterCS__Group__2__Impl rule__ParameterCS__Group__3 ;
    public final void rule__ParameterCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8319:1: ( rule__ParameterCS__Group__2__Impl rule__ParameterCS__Group__3 )
            // InternalQVTbase.g:8320:2: rule__ParameterCS__Group__2__Impl rule__ParameterCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_39);
            rule__ParameterCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group__3();

            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"
    // InternalQVTbase.g:8327:1: rule__ParameterCS__Group__2__Impl : ( ( rule__ParameterCS__Group_2__0 )? ) ;
    public final void rule__ParameterCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8331:1: ( ( ( rule__ParameterCS__Group_2__0 )? ) )
            // InternalQVTbase.g:8332:1: ( ( rule__ParameterCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:8332:1: ( ( rule__ParameterCS__Group_2__0 )? )
            // InternalQVTbase.g:8333:1: ( rule__ParameterCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:8334:1: ( rule__ParameterCS__Group_2__0 )?
            int alt99=2;
            int LA99_0 = input.LA(1);

            if ( (LA99_0==62) ) {
                int LA99_1 = input.LA(2);

                if ( ((LA99_1>=105 && LA99_1<=106)||(LA99_1>=111 && LA99_1<=112)) ) {
                    alt99=1;
                }
            }
            switch (alt99) {
                case 1 :
                    // InternalQVTbase.g:8334:2: rule__ParameterCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group__2__Impl"


    // $ANTLR start "rule__ParameterCS__Group__3"
    // InternalQVTbase.g:8344:1: rule__ParameterCS__Group__3 : rule__ParameterCS__Group__3__Impl ;
    public final void rule__ParameterCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8348:1: ( rule__ParameterCS__Group__3__Impl )
            // InternalQVTbase.g:8349:2: rule__ParameterCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group__3"


    // $ANTLR start "rule__ParameterCS__Group__3__Impl"
    // InternalQVTbase.g:8355:1: rule__ParameterCS__Group__3__Impl : ( ( rule__ParameterCS__Group_3__0 )? ) ;
    public final void rule__ParameterCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8359:1: ( ( ( rule__ParameterCS__Group_3__0 )? ) )
            // InternalQVTbase.g:8360:1: ( ( rule__ParameterCS__Group_3__0 )? )
            {
            // InternalQVTbase.g:8360:1: ( ( rule__ParameterCS__Group_3__0 )? )
            // InternalQVTbase.g:8361:1: ( rule__ParameterCS__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup_3());
            }
            // InternalQVTbase.g:8362:1: ( rule__ParameterCS__Group_3__0 )?
            int alt100=2;
            int LA100_0 = input.LA(1);

            if ( (LA100_0==62) ) {
                alt100=1;
            }
            switch (alt100) {
                case 1 :
                    // InternalQVTbase.g:8362:2: rule__ParameterCS__Group_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ParameterCS__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group__3__Impl"


    // $ANTLR start "rule__ParameterCS__Group_1__0"
    // InternalQVTbase.g:8380:1: rule__ParameterCS__Group_1__0 : rule__ParameterCS__Group_1__0__Impl rule__ParameterCS__Group_1__1 ;
    public final void rule__ParameterCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8384:1: ( rule__ParameterCS__Group_1__0__Impl rule__ParameterCS__Group_1__1 )
            // InternalQVTbase.g:8385:2: rule__ParameterCS__Group_1__0__Impl rule__ParameterCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__ParameterCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_1__0"


    // $ANTLR start "rule__ParameterCS__Group_1__0__Impl"
    // InternalQVTbase.g:8392:1: rule__ParameterCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__ParameterCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8396:1: ( ( ':' ) )
            // InternalQVTbase.g:8397:1: ( ':' )
            {
            // InternalQVTbase.g:8397:1: ( ':' )
            // InternalQVTbase.g:8398:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getColonKeyword_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_1__0__Impl"


    // $ANTLR start "rule__ParameterCS__Group_1__1"
    // InternalQVTbase.g:8411:1: rule__ParameterCS__Group_1__1 : rule__ParameterCS__Group_1__1__Impl ;
    public final void rule__ParameterCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8415:1: ( rule__ParameterCS__Group_1__1__Impl )
            // InternalQVTbase.g:8416:2: rule__ParameterCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__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__ParameterCS__Group_1__1"


    // $ANTLR start "rule__ParameterCS__Group_1__1__Impl"
    // InternalQVTbase.g:8422:1: rule__ParameterCS__Group_1__1__Impl : ( ( rule__ParameterCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__ParameterCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8426:1: ( ( ( rule__ParameterCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:8427:1: ( ( rule__ParameterCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:8427:1: ( ( rule__ParameterCS__OwnedTypeAssignment_1_1 ) )
            // InternalQVTbase.g:8428:1: ( rule__ParameterCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalQVTbase.g:8429:1: ( rule__ParameterCS__OwnedTypeAssignment_1_1 )
            // InternalQVTbase.g:8429:2: rule__ParameterCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_1__1__Impl"


    // $ANTLR start "rule__ParameterCS__Group_2__0"
    // InternalQVTbase.g:8443:1: rule__ParameterCS__Group_2__0 : rule__ParameterCS__Group_2__0__Impl rule__ParameterCS__Group_2__1 ;
    public final void rule__ParameterCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8447:1: ( rule__ParameterCS__Group_2__0__Impl rule__ParameterCS__Group_2__1 )
            // InternalQVTbase.g:8448:2: rule__ParameterCS__Group_2__0__Impl rule__ParameterCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_40);
            rule__ParameterCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__0"


    // $ANTLR start "rule__ParameterCS__Group_2__0__Impl"
    // InternalQVTbase.g:8455:1: rule__ParameterCS__Group_2__0__Impl : ( '{' ) ;
    public final void rule__ParameterCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8459:1: ( ( '{' ) )
            // InternalQVTbase.g:8460:1: ( '{' )
            {
            // InternalQVTbase.g:8460:1: ( '{' )
            // InternalQVTbase.g:8461:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getLeftCurlyBracketKeyword_2_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getLeftCurlyBracketKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__0__Impl"


    // $ANTLR start "rule__ParameterCS__Group_2__1"
    // InternalQVTbase.g:8474:1: rule__ParameterCS__Group_2__1 : rule__ParameterCS__Group_2__1__Impl rule__ParameterCS__Group_2__2 ;
    public final void rule__ParameterCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8478:1: ( rule__ParameterCS__Group_2__1__Impl rule__ParameterCS__Group_2__2 )
            // InternalQVTbase.g:8479:2: rule__ParameterCS__Group_2__1__Impl rule__ParameterCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__ParameterCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__1"


    // $ANTLR start "rule__ParameterCS__Group_2__1__Impl"
    // InternalQVTbase.g:8486:1: rule__ParameterCS__Group_2__1__Impl : ( ( ( rule__ParameterCS__Group_2_1__0 ) ) ( ( rule__ParameterCS__Group_2_1__0 )* ) ) ;
    public final void rule__ParameterCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8490:1: ( ( ( ( rule__ParameterCS__Group_2_1__0 ) ) ( ( rule__ParameterCS__Group_2_1__0 )* ) ) )
            // InternalQVTbase.g:8491:1: ( ( ( rule__ParameterCS__Group_2_1__0 ) ) ( ( rule__ParameterCS__Group_2_1__0 )* ) )
            {
            // InternalQVTbase.g:8491:1: ( ( ( rule__ParameterCS__Group_2_1__0 ) ) ( ( rule__ParameterCS__Group_2_1__0 )* ) )
            // InternalQVTbase.g:8492:1: ( ( rule__ParameterCS__Group_2_1__0 ) ) ( ( rule__ParameterCS__Group_2_1__0 )* )
            {
            // InternalQVTbase.g:8492:1: ( ( rule__ParameterCS__Group_2_1__0 ) )
            // InternalQVTbase.g:8493:1: ( rule__ParameterCS__Group_2_1__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:8494:1: ( rule__ParameterCS__Group_2_1__0 )
            // InternalQVTbase.g:8494:2: rule__ParameterCS__Group_2_1__0
            {
            pushFollow(FollowSets000.FOLLOW_41);
            rule__ParameterCS__Group_2_1__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getGroup_2_1());
            }

            }

            // InternalQVTbase.g:8497:1: ( ( rule__ParameterCS__Group_2_1__0 )* )
            // InternalQVTbase.g:8498:1: ( rule__ParameterCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:8499:1: ( rule__ParameterCS__Group_2_1__0 )*
            loop101:
            do {
                int alt101=2;
                int LA101_0 = input.LA(1);

                if ( ((LA101_0>=105 && LA101_0<=106)||(LA101_0>=111 && LA101_0<=112)) ) {
                    alt101=1;
                }


                switch (alt101) {
            	case 1 :
            	    // InternalQVTbase.g:8499:2: rule__ParameterCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_41);
            	    rule__ParameterCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop101;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getGroup_2_1());
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__1__Impl"


    // $ANTLR start "rule__ParameterCS__Group_2__2"
    // InternalQVTbase.g:8510:1: rule__ParameterCS__Group_2__2 : rule__ParameterCS__Group_2__2__Impl ;
    public final void rule__ParameterCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8514:1: ( rule__ParameterCS__Group_2__2__Impl )
            // InternalQVTbase.g:8515:2: rule__ParameterCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__2"


    // $ANTLR start "rule__ParameterCS__Group_2__2__Impl"
    // InternalQVTbase.g:8521:1: rule__ParameterCS__Group_2__2__Impl : ( '}' ) ;
    public final void rule__ParameterCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8525:1: ( ( '}' ) )
            // InternalQVTbase.g:8526:1: ( '}' )
            {
            // InternalQVTbase.g:8526:1: ( '}' )
            // InternalQVTbase.g:8527:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getRightCurlyBracketKeyword_2_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getRightCurlyBracketKeyword_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2__2__Impl"


    // $ANTLR start "rule__ParameterCS__Group_2_1__0"
    // InternalQVTbase.g:8546:1: rule__ParameterCS__Group_2_1__0 : rule__ParameterCS__Group_2_1__0__Impl rule__ParameterCS__Group_2_1__1 ;
    public final void rule__ParameterCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8550:1: ( rule__ParameterCS__Group_2_1__0__Impl rule__ParameterCS__Group_2_1__1 )
            // InternalQVTbase.g:8551:2: rule__ParameterCS__Group_2_1__0__Impl rule__ParameterCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__ParameterCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__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__ParameterCS__Group_2_1__0"


    // $ANTLR start "rule__ParameterCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:8558:1: rule__ParameterCS__Group_2_1__0__Impl : ( ( rule__ParameterCS__Alternatives_2_1_0 ) ) ;
    public final void rule__ParameterCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8562:1: ( ( ( rule__ParameterCS__Alternatives_2_1_0 ) ) )
            // InternalQVTbase.g:8563:1: ( ( rule__ParameterCS__Alternatives_2_1_0 ) )
            {
            // InternalQVTbase.g:8563:1: ( ( rule__ParameterCS__Alternatives_2_1_0 ) )
            // InternalQVTbase.g:8564:1: ( rule__ParameterCS__Alternatives_2_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getAlternatives_2_1_0());
            }
            // InternalQVTbase.g:8565:1: ( rule__ParameterCS__Alternatives_2_1_0 )
            // InternalQVTbase.g:8565:2: rule__ParameterCS__Alternatives_2_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Alternatives_2_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getAlternatives_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__ParameterCS__Group_2_1__1"
    // InternalQVTbase.g:8575:1: rule__ParameterCS__Group_2_1__1 : rule__ParameterCS__Group_2_1__1__Impl ;
    public final void rule__ParameterCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8579:1: ( rule__ParameterCS__Group_2_1__1__Impl )
            // InternalQVTbase.g:8580:2: rule__ParameterCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__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__ParameterCS__Group_2_1__1"


    // $ANTLR start "rule__ParameterCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:8586:1: rule__ParameterCS__Group_2_1__1__Impl : ( ( ',' )? ) ;
    public final void rule__ParameterCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8590:1: ( ( ( ',' )? ) )
            // InternalQVTbase.g:8591:1: ( ( ',' )? )
            {
            // InternalQVTbase.g:8591:1: ( ( ',' )? )
            // InternalQVTbase.g:8592:1: ( ',' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getCommaKeyword_2_1_1());
            }
            // InternalQVTbase.g:8593:1: ( ',' )?
            int alt102=2;
            int LA102_0 = input.LA(1);

            if ( (LA102_0==64) ) {
                alt102=1;
            }
            switch (alt102) {
                case 1 :
                    // InternalQVTbase.g:8594:2: ','
                    {
                    match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getCommaKeyword_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__ParameterCS__Group_3__0"
    // InternalQVTbase.g:8609:1: rule__ParameterCS__Group_3__0 : rule__ParameterCS__Group_3__0__Impl rule__ParameterCS__Group_3__1 ;
    public final void rule__ParameterCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8613:1: ( rule__ParameterCS__Group_3__0__Impl rule__ParameterCS__Group_3__1 )
            // InternalQVTbase.g:8614:2: rule__ParameterCS__Group_3__0__Impl rule__ParameterCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__ParameterCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_3__0"


    // $ANTLR start "rule__ParameterCS__Group_3__0__Impl"
    // InternalQVTbase.g:8621:1: rule__ParameterCS__Group_3__0__Impl : ( '{' ) ;
    public final void rule__ParameterCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8625:1: ( ( '{' ) )
            // InternalQVTbase.g:8626:1: ( '{' )
            {
            // InternalQVTbase.g:8626:1: ( '{' )
            // InternalQVTbase.g:8627:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getLeftCurlyBracketKeyword_3_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getLeftCurlyBracketKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_3__0__Impl"


    // $ANTLR start "rule__ParameterCS__Group_3__1"
    // InternalQVTbase.g:8640:1: rule__ParameterCS__Group_3__1 : rule__ParameterCS__Group_3__1__Impl ;
    public final void rule__ParameterCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8644:1: ( rule__ParameterCS__Group_3__1__Impl )
            // InternalQVTbase.g:8645:2: rule__ParameterCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ParameterCS__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__ParameterCS__Group_3__1"


    // $ANTLR start "rule__ParameterCS__Group_3__1__Impl"
    // InternalQVTbase.g:8651:1: rule__ParameterCS__Group_3__1__Impl : ( '}' ) ;
    public final void rule__ParameterCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8655:1: ( ( '}' ) )
            // InternalQVTbase.g:8656:1: ( '}' )
            {
            // InternalQVTbase.g:8656:1: ( '}' )
            // InternalQVTbase.g:8657:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getRightCurlyBracketKeyword_3_1());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getRightCurlyBracketKeyword_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__Group_3__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__0"
    // InternalQVTbase.g:8674:1: rule__ReferenceCS__Group__0 : rule__ReferenceCS__Group__0__Impl rule__ReferenceCS__Group__1 ;
    public final void rule__ReferenceCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8678:1: ( rule__ReferenceCS__Group__0__Impl rule__ReferenceCS__Group__1 )
            // InternalQVTbase.g:8679:2: rule__ReferenceCS__Group__0__Impl rule__ReferenceCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_42);
            rule__ReferenceCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__0"


    // $ANTLR start "rule__ReferenceCS__Group__0__Impl"
    // InternalQVTbase.g:8686:1: rule__ReferenceCS__Group__0__Impl : ( ( rule__ReferenceCS__Alternatives_0 )? ) ;
    public final void rule__ReferenceCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8690:1: ( ( ( rule__ReferenceCS__Alternatives_0 )? ) )
            // InternalQVTbase.g:8691:1: ( ( rule__ReferenceCS__Alternatives_0 )? )
            {
            // InternalQVTbase.g:8691:1: ( ( rule__ReferenceCS__Alternatives_0 )? )
            // InternalQVTbase.g:8692:1: ( rule__ReferenceCS__Alternatives_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getAlternatives_0());
            }
            // InternalQVTbase.g:8693:1: ( rule__ReferenceCS__Alternatives_0 )?
            int alt103=2;
            int LA103_0 = input.LA(1);

            if ( ((LA103_0>=99 && LA103_0<=100)) ) {
                alt103=1;
            }
            switch (alt103) {
                case 1 :
                    // InternalQVTbase.g:8693:2: rule__ReferenceCS__Alternatives_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Alternatives_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__1"
    // InternalQVTbase.g:8703:1: rule__ReferenceCS__Group__1 : rule__ReferenceCS__Group__1__Impl rule__ReferenceCS__Group__2 ;
    public final void rule__ReferenceCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8707:1: ( rule__ReferenceCS__Group__1__Impl rule__ReferenceCS__Group__2 )
            // InternalQVTbase.g:8708:2: rule__ReferenceCS__Group__1__Impl rule__ReferenceCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__ReferenceCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__1"


    // $ANTLR start "rule__ReferenceCS__Group__1__Impl"
    // InternalQVTbase.g:8715:1: rule__ReferenceCS__Group__1__Impl : ( 'property' ) ;
    public final void rule__ReferenceCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8719:1: ( ( 'property' ) )
            // InternalQVTbase.g:8720:1: ( 'property' )
            {
            // InternalQVTbase.g:8720:1: ( 'property' )
            // InternalQVTbase.g:8721:1: 'property'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getPropertyKeyword_1());
            }
            match(input,75,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getPropertyKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__2"
    // InternalQVTbase.g:8734:1: rule__ReferenceCS__Group__2 : rule__ReferenceCS__Group__2__Impl rule__ReferenceCS__Group__3 ;
    public final void rule__ReferenceCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8738:1: ( rule__ReferenceCS__Group__2__Impl rule__ReferenceCS__Group__3 )
            // InternalQVTbase.g:8739:2: rule__ReferenceCS__Group__2__Impl rule__ReferenceCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__ReferenceCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__2"


    // $ANTLR start "rule__ReferenceCS__Group__2__Impl"
    // InternalQVTbase.g:8746:1: rule__ReferenceCS__Group__2__Impl : ( ( rule__ReferenceCS__NameAssignment_2 ) ) ;
    public final void rule__ReferenceCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8750:1: ( ( ( rule__ReferenceCS__NameAssignment_2 ) ) )
            // InternalQVTbase.g:8751:1: ( ( rule__ReferenceCS__NameAssignment_2 ) )
            {
            // InternalQVTbase.g:8751:1: ( ( rule__ReferenceCS__NameAssignment_2 ) )
            // InternalQVTbase.g:8752:1: ( rule__ReferenceCS__NameAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getNameAssignment_2());
            }
            // InternalQVTbase.g:8753:1: ( rule__ReferenceCS__NameAssignment_2 )
            // InternalQVTbase.g:8753:2: rule__ReferenceCS__NameAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__NameAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getNameAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__2__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__3"
    // InternalQVTbase.g:8763:1: rule__ReferenceCS__Group__3 : rule__ReferenceCS__Group__3__Impl rule__ReferenceCS__Group__4 ;
    public final void rule__ReferenceCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8767:1: ( rule__ReferenceCS__Group__3__Impl rule__ReferenceCS__Group__4 )
            // InternalQVTbase.g:8768:2: rule__ReferenceCS__Group__3__Impl rule__ReferenceCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__ReferenceCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__3"


    // $ANTLR start "rule__ReferenceCS__Group__3__Impl"
    // InternalQVTbase.g:8775:1: rule__ReferenceCS__Group__3__Impl : ( ( rule__ReferenceCS__Group_3__0 )? ) ;
    public final void rule__ReferenceCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8779:1: ( ( ( rule__ReferenceCS__Group_3__0 )? ) )
            // InternalQVTbase.g:8780:1: ( ( rule__ReferenceCS__Group_3__0 )? )
            {
            // InternalQVTbase.g:8780:1: ( ( rule__ReferenceCS__Group_3__0 )? )
            // InternalQVTbase.g:8781:1: ( rule__ReferenceCS__Group_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_3());
            }
            // InternalQVTbase.g:8782:1: ( rule__ReferenceCS__Group_3__0 )?
            int alt104=2;
            int LA104_0 = input.LA(1);

            if ( (LA104_0==76) ) {
                alt104=1;
            }
            switch (alt104) {
                case 1 :
                    // InternalQVTbase.g:8782:2: rule__ReferenceCS__Group_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__3__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__4"
    // InternalQVTbase.g:8792:1: rule__ReferenceCS__Group__4 : rule__ReferenceCS__Group__4__Impl rule__ReferenceCS__Group__5 ;
    public final void rule__ReferenceCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8796:1: ( rule__ReferenceCS__Group__4__Impl rule__ReferenceCS__Group__5 )
            // InternalQVTbase.g:8797:2: rule__ReferenceCS__Group__4__Impl rule__ReferenceCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__ReferenceCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__4"


    // $ANTLR start "rule__ReferenceCS__Group__4__Impl"
    // InternalQVTbase.g:8804:1: rule__ReferenceCS__Group__4__Impl : ( ( rule__ReferenceCS__Group_4__0 )? ) ;
    public final void rule__ReferenceCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8808:1: ( ( ( rule__ReferenceCS__Group_4__0 )? ) )
            // InternalQVTbase.g:8809:1: ( ( rule__ReferenceCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:8809:1: ( ( rule__ReferenceCS__Group_4__0 )? )
            // InternalQVTbase.g:8810:1: ( rule__ReferenceCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:8811:1: ( rule__ReferenceCS__Group_4__0 )?
            int alt105=2;
            int LA105_0 = input.LA(1);

            if ( (LA105_0==61) ) {
                alt105=1;
            }
            switch (alt105) {
                case 1 :
                    // InternalQVTbase.g:8811:2: rule__ReferenceCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__4__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__5"
    // InternalQVTbase.g:8821:1: rule__ReferenceCS__Group__5 : rule__ReferenceCS__Group__5__Impl rule__ReferenceCS__Group__6 ;
    public final void rule__ReferenceCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8825:1: ( rule__ReferenceCS__Group__5__Impl rule__ReferenceCS__Group__6 )
            // InternalQVTbase.g:8826:2: rule__ReferenceCS__Group__5__Impl rule__ReferenceCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__ReferenceCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__5"


    // $ANTLR start "rule__ReferenceCS__Group__5__Impl"
    // InternalQVTbase.g:8833:1: rule__ReferenceCS__Group__5__Impl : ( ( rule__ReferenceCS__Group_5__0 )? ) ;
    public final void rule__ReferenceCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8837:1: ( ( ( rule__ReferenceCS__Group_5__0 )? ) )
            // InternalQVTbase.g:8838:1: ( ( rule__ReferenceCS__Group_5__0 )? )
            {
            // InternalQVTbase.g:8838:1: ( ( rule__ReferenceCS__Group_5__0 )? )
            // InternalQVTbase.g:8839:1: ( rule__ReferenceCS__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_5());
            }
            // InternalQVTbase.g:8840:1: ( rule__ReferenceCS__Group_5__0 )?
            int alt106=2;
            int LA106_0 = input.LA(1);

            if ( (LA106_0==29) ) {
                alt106=1;
            }
            switch (alt106) {
                case 1 :
                    // InternalQVTbase.g:8840:2: rule__ReferenceCS__Group_5__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__5__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__6"
    // InternalQVTbase.g:8850:1: rule__ReferenceCS__Group__6 : rule__ReferenceCS__Group__6__Impl rule__ReferenceCS__Group__7 ;
    public final void rule__ReferenceCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8854:1: ( rule__ReferenceCS__Group__6__Impl rule__ReferenceCS__Group__7 )
            // InternalQVTbase.g:8855:2: rule__ReferenceCS__Group__6__Impl rule__ReferenceCS__Group__7
            {
            pushFollow(FollowSets000.FOLLOW_43);
            rule__ReferenceCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__6"


    // $ANTLR start "rule__ReferenceCS__Group__6__Impl"
    // InternalQVTbase.g:8862:1: rule__ReferenceCS__Group__6__Impl : ( ( rule__ReferenceCS__Group_6__0 )? ) ;
    public final void rule__ReferenceCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8866:1: ( ( ( rule__ReferenceCS__Group_6__0 )? ) )
            // InternalQVTbase.g:8867:1: ( ( rule__ReferenceCS__Group_6__0 )? )
            {
            // InternalQVTbase.g:8867:1: ( ( rule__ReferenceCS__Group_6__0 )? )
            // InternalQVTbase.g:8868:1: ( rule__ReferenceCS__Group_6__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_6());
            }
            // InternalQVTbase.g:8869:1: ( rule__ReferenceCS__Group_6__0 )?
            int alt107=2;
            int LA107_0 = input.LA(1);

            if ( (LA107_0==62) ) {
                int LA107_1 = input.LA(2);

                if ( ((LA107_1>=101 && LA107_1<=102)||(LA107_1>=105 && LA107_1<=116)||(LA107_1>=119 && LA107_1<=122)) ) {
                    alt107=1;
                }
            }
            switch (alt107) {
                case 1 :
                    // InternalQVTbase.g:8869:2: rule__ReferenceCS__Group_6__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__6__Impl"


    // $ANTLR start "rule__ReferenceCS__Group__7"
    // InternalQVTbase.g:8879:1: rule__ReferenceCS__Group__7 : rule__ReferenceCS__Group__7__Impl ;
    public final void rule__ReferenceCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8883:1: ( rule__ReferenceCS__Group__7__Impl )
            // InternalQVTbase.g:8884:2: rule__ReferenceCS__Group__7__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__7"


    // $ANTLR start "rule__ReferenceCS__Group__7__Impl"
    // InternalQVTbase.g:8890:1: rule__ReferenceCS__Group__7__Impl : ( ( rule__ReferenceCS__Alternatives_7 ) ) ;
    public final void rule__ReferenceCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8894:1: ( ( ( rule__ReferenceCS__Alternatives_7 ) ) )
            // InternalQVTbase.g:8895:1: ( ( rule__ReferenceCS__Alternatives_7 ) )
            {
            // InternalQVTbase.g:8895:1: ( ( rule__ReferenceCS__Alternatives_7 ) )
            // InternalQVTbase.g:8896:1: ( rule__ReferenceCS__Alternatives_7 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getAlternatives_7());
            }
            // InternalQVTbase.g:8897:1: ( rule__ReferenceCS__Alternatives_7 )
            // InternalQVTbase.g:8897:2: rule__ReferenceCS__Alternatives_7
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Alternatives_7();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getAlternatives_7());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group__7__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_0_0__0"
    // InternalQVTbase.g:8923:1: rule__ReferenceCS__Group_0_0__0 : rule__ReferenceCS__Group_0_0__0__Impl rule__ReferenceCS__Group_0_0__1 ;
    public final void rule__ReferenceCS__Group_0_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8927:1: ( rule__ReferenceCS__Group_0_0__0__Impl rule__ReferenceCS__Group_0_0__1 )
            // InternalQVTbase.g:8928:2: rule__ReferenceCS__Group_0_0__0__Impl rule__ReferenceCS__Group_0_0__1
            {
            pushFollow(FollowSets000.FOLLOW_7);
            rule__ReferenceCS__Group_0_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_0_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_0__0"


    // $ANTLR start "rule__ReferenceCS__Group_0_0__0__Impl"
    // InternalQVTbase.g:8935:1: rule__ReferenceCS__Group_0_0__0__Impl : ( ( rule__ReferenceCS__QualifiersAssignment_0_0_0 ) ) ;
    public final void rule__ReferenceCS__Group_0_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8939:1: ( ( ( rule__ReferenceCS__QualifiersAssignment_0_0_0 ) ) )
            // InternalQVTbase.g:8940:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_0_0 ) )
            {
            // InternalQVTbase.g:8940:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_0_0 ) )
            // InternalQVTbase.g:8941:1: ( rule__ReferenceCS__QualifiersAssignment_0_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_0_0());
            }
            // InternalQVTbase.g:8942:1: ( rule__ReferenceCS__QualifiersAssignment_0_0_0 )
            // InternalQVTbase.g:8942:2: rule__ReferenceCS__QualifiersAssignment_0_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__QualifiersAssignment_0_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_0__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_0_0__1"
    // InternalQVTbase.g:8952:1: rule__ReferenceCS__Group_0_0__1 : rule__ReferenceCS__Group_0_0__1__Impl ;
    public final void rule__ReferenceCS__Group_0_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8956:1: ( rule__ReferenceCS__Group_0_0__1__Impl )
            // InternalQVTbase.g:8957:2: rule__ReferenceCS__Group_0_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_0_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_0__1"


    // $ANTLR start "rule__ReferenceCS__Group_0_0__1__Impl"
    // InternalQVTbase.g:8963:1: rule__ReferenceCS__Group_0_0__1__Impl : ( ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )? ) ;
    public final void rule__ReferenceCS__Group_0_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8967:1: ( ( ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )? ) )
            // InternalQVTbase.g:8968:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )? )
            {
            // InternalQVTbase.g:8968:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )? )
            // InternalQVTbase.g:8969:1: ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_0_1());
            }
            // InternalQVTbase.g:8970:1: ( rule__ReferenceCS__QualifiersAssignment_0_0_1 )?
            int alt108=2;
            int LA108_0 = input.LA(1);

            if ( (LA108_0==100) ) {
                alt108=1;
            }
            switch (alt108) {
                case 1 :
                    // InternalQVTbase.g:8970:2: rule__ReferenceCS__QualifiersAssignment_0_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_0_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_0__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_0_1__0"
    // InternalQVTbase.g:8984:1: rule__ReferenceCS__Group_0_1__0 : rule__ReferenceCS__Group_0_1__0__Impl rule__ReferenceCS__Group_0_1__1 ;
    public final void rule__ReferenceCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:8988:1: ( rule__ReferenceCS__Group_0_1__0__Impl rule__ReferenceCS__Group_0_1__1 )
            // InternalQVTbase.g:8989:2: rule__ReferenceCS__Group_0_1__0__Impl rule__ReferenceCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_8);
            rule__ReferenceCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_1__0"


    // $ANTLR start "rule__ReferenceCS__Group_0_1__0__Impl"
    // InternalQVTbase.g:8996:1: rule__ReferenceCS__Group_0_1__0__Impl : ( ( rule__ReferenceCS__QualifiersAssignment_0_1_0 ) ) ;
    public final void rule__ReferenceCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9000:1: ( ( ( rule__ReferenceCS__QualifiersAssignment_0_1_0 ) ) )
            // InternalQVTbase.g:9001:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_1_0 ) )
            {
            // InternalQVTbase.g:9001:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_1_0 ) )
            // InternalQVTbase.g:9002:1: ( rule__ReferenceCS__QualifiersAssignment_0_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_1_0());
            }
            // InternalQVTbase.g:9003:1: ( rule__ReferenceCS__QualifiersAssignment_0_1_0 )
            // InternalQVTbase.g:9003:2: rule__ReferenceCS__QualifiersAssignment_0_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__QualifiersAssignment_0_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_0_1__1"
    // InternalQVTbase.g:9013:1: rule__ReferenceCS__Group_0_1__1 : rule__ReferenceCS__Group_0_1__1__Impl ;
    public final void rule__ReferenceCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9017:1: ( rule__ReferenceCS__Group_0_1__1__Impl )
            // InternalQVTbase.g:9018:2: rule__ReferenceCS__Group_0_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_1__1"


    // $ANTLR start "rule__ReferenceCS__Group_0_1__1__Impl"
    // InternalQVTbase.g:9024:1: rule__ReferenceCS__Group_0_1__1__Impl : ( ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )? ) ;
    public final void rule__ReferenceCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9028:1: ( ( ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )? ) )
            // InternalQVTbase.g:9029:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )? )
            {
            // InternalQVTbase.g:9029:1: ( ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )? )
            // InternalQVTbase.g:9030:1: ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_1_1());
            }
            // InternalQVTbase.g:9031:1: ( rule__ReferenceCS__QualifiersAssignment_0_1_1 )?
            int alt109=2;
            int LA109_0 = input.LA(1);

            if ( (LA109_0==99) ) {
                alt109=1;
            }
            switch (alt109) {
                case 1 :
                    // InternalQVTbase.g:9031:2: rule__ReferenceCS__QualifiersAssignment_0_1_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__QualifiersAssignment_0_1_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_3__0"
    // InternalQVTbase.g:9045:1: rule__ReferenceCS__Group_3__0 : rule__ReferenceCS__Group_3__0__Impl rule__ReferenceCS__Group_3__1 ;
    public final void rule__ReferenceCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9049:1: ( rule__ReferenceCS__Group_3__0__Impl rule__ReferenceCS__Group_3__1 )
            // InternalQVTbase.g:9050:2: rule__ReferenceCS__Group_3__0__Impl rule__ReferenceCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__ReferenceCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_3__0"


    // $ANTLR start "rule__ReferenceCS__Group_3__0__Impl"
    // InternalQVTbase.g:9057:1: rule__ReferenceCS__Group_3__0__Impl : ( '#' ) ;
    public final void rule__ReferenceCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9061:1: ( ( '#' ) )
            // InternalQVTbase.g:9062:1: ( '#' )
            {
            // InternalQVTbase.g:9062:1: ( '#' )
            // InternalQVTbase.g:9063:1: '#'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getNumberSignKeyword_3_0());
            }
            match(input,76,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getNumberSignKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_3__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_3__1"
    // InternalQVTbase.g:9076:1: rule__ReferenceCS__Group_3__1 : rule__ReferenceCS__Group_3__1__Impl ;
    public final void rule__ReferenceCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9080:1: ( rule__ReferenceCS__Group_3__1__Impl )
            // InternalQVTbase.g:9081:2: rule__ReferenceCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__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__ReferenceCS__Group_3__1"


    // $ANTLR start "rule__ReferenceCS__Group_3__1__Impl"
    // InternalQVTbase.g:9087:1: rule__ReferenceCS__Group_3__1__Impl : ( ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 ) ) ;
    public final void rule__ReferenceCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9091:1: ( ( ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 ) ) )
            // InternalQVTbase.g:9092:1: ( ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 ) )
            {
            // InternalQVTbase.g:9092:1: ( ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 ) )
            // InternalQVTbase.g:9093:1: ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getReferredOppositeAssignment_3_1());
            }
            // InternalQVTbase.g:9094:1: ( rule__ReferenceCS__ReferredOppositeAssignment_3_1 )
            // InternalQVTbase.g:9094:2: rule__ReferenceCS__ReferredOppositeAssignment_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__ReferredOppositeAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getReferredOppositeAssignment_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_3__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_4__0"
    // InternalQVTbase.g:9108:1: rule__ReferenceCS__Group_4__0 : rule__ReferenceCS__Group_4__0__Impl rule__ReferenceCS__Group_4__1 ;
    public final void rule__ReferenceCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9112:1: ( rule__ReferenceCS__Group_4__0__Impl rule__ReferenceCS__Group_4__1 )
            // InternalQVTbase.g:9113:2: rule__ReferenceCS__Group_4__0__Impl rule__ReferenceCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__ReferenceCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_4__0"


    // $ANTLR start "rule__ReferenceCS__Group_4__0__Impl"
    // InternalQVTbase.g:9120:1: rule__ReferenceCS__Group_4__0__Impl : ( ':' ) ;
    public final void rule__ReferenceCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9124:1: ( ( ':' ) )
            // InternalQVTbase.g:9125:1: ( ':' )
            {
            // InternalQVTbase.g:9125:1: ( ':' )
            // InternalQVTbase.g:9126:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getColonKeyword_4_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getColonKeyword_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_4__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_4__1"
    // InternalQVTbase.g:9139:1: rule__ReferenceCS__Group_4__1 : rule__ReferenceCS__Group_4__1__Impl ;
    public final void rule__ReferenceCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9143:1: ( rule__ReferenceCS__Group_4__1__Impl )
            // InternalQVTbase.g:9144:2: rule__ReferenceCS__Group_4__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_4__1"


    // $ANTLR start "rule__ReferenceCS__Group_4__1__Impl"
    // InternalQVTbase.g:9150:1: rule__ReferenceCS__Group_4__1__Impl : ( ( rule__ReferenceCS__OwnedTypeAssignment_4_1 ) ) ;
    public final void rule__ReferenceCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9154:1: ( ( ( rule__ReferenceCS__OwnedTypeAssignment_4_1 ) ) )
            // InternalQVTbase.g:9155:1: ( ( rule__ReferenceCS__OwnedTypeAssignment_4_1 ) )
            {
            // InternalQVTbase.g:9155:1: ( ( rule__ReferenceCS__OwnedTypeAssignment_4_1 ) )
            // InternalQVTbase.g:9156:1: ( rule__ReferenceCS__OwnedTypeAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedTypeAssignment_4_1());
            }
            // InternalQVTbase.g:9157:1: ( rule__ReferenceCS__OwnedTypeAssignment_4_1 )
            // InternalQVTbase.g:9157:2: rule__ReferenceCS__OwnedTypeAssignment_4_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__OwnedTypeAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedTypeAssignment_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_4__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_5__0"
    // InternalQVTbase.g:9171:1: rule__ReferenceCS__Group_5__0 : rule__ReferenceCS__Group_5__0__Impl rule__ReferenceCS__Group_5__1 ;
    public final void rule__ReferenceCS__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9175:1: ( rule__ReferenceCS__Group_5__0__Impl rule__ReferenceCS__Group_5__1 )
            // InternalQVTbase.g:9176:2: rule__ReferenceCS__Group_5__0__Impl rule__ReferenceCS__Group_5__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__ReferenceCS__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_5__0"


    // $ANTLR start "rule__ReferenceCS__Group_5__0__Impl"
    // InternalQVTbase.g:9183:1: rule__ReferenceCS__Group_5__0__Impl : ( '=' ) ;
    public final void rule__ReferenceCS__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9187:1: ( ( '=' ) )
            // InternalQVTbase.g:9188:1: ( '=' )
            {
            // InternalQVTbase.g:9188:1: ( '=' )
            // InternalQVTbase.g:9189:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getEqualsSignKeyword_5_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getEqualsSignKeyword_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_5__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_5__1"
    // InternalQVTbase.g:9202:1: rule__ReferenceCS__Group_5__1 : rule__ReferenceCS__Group_5__1__Impl ;
    public final void rule__ReferenceCS__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9206:1: ( rule__ReferenceCS__Group_5__1__Impl )
            // InternalQVTbase.g:9207:2: rule__ReferenceCS__Group_5__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_5__1"


    // $ANTLR start "rule__ReferenceCS__Group_5__1__Impl"
    // InternalQVTbase.g:9213:1: rule__ReferenceCS__Group_5__1__Impl : ( ( rule__ReferenceCS__DefaultAssignment_5_1 ) ) ;
    public final void rule__ReferenceCS__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9217:1: ( ( ( rule__ReferenceCS__DefaultAssignment_5_1 ) ) )
            // InternalQVTbase.g:9218:1: ( ( rule__ReferenceCS__DefaultAssignment_5_1 ) )
            {
            // InternalQVTbase.g:9218:1: ( ( rule__ReferenceCS__DefaultAssignment_5_1 ) )
            // InternalQVTbase.g:9219:1: ( rule__ReferenceCS__DefaultAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getDefaultAssignment_5_1());
            }
            // InternalQVTbase.g:9220:1: ( rule__ReferenceCS__DefaultAssignment_5_1 )
            // InternalQVTbase.g:9220:2: rule__ReferenceCS__DefaultAssignment_5_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__DefaultAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getDefaultAssignment_5_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_5__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_6__0"
    // InternalQVTbase.g:9234:1: rule__ReferenceCS__Group_6__0 : rule__ReferenceCS__Group_6__0__Impl rule__ReferenceCS__Group_6__1 ;
    public final void rule__ReferenceCS__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9238:1: ( rule__ReferenceCS__Group_6__0__Impl rule__ReferenceCS__Group_6__1 )
            // InternalQVTbase.g:9239:2: rule__ReferenceCS__Group_6__0__Impl rule__ReferenceCS__Group_6__1
            {
            pushFollow(FollowSets000.FOLLOW_44);
            rule__ReferenceCS__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__0"


    // $ANTLR start "rule__ReferenceCS__Group_6__0__Impl"
    // InternalQVTbase.g:9246:1: rule__ReferenceCS__Group_6__0__Impl : ( '{' ) ;
    public final void rule__ReferenceCS__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9250:1: ( ( '{' ) )
            // InternalQVTbase.g:9251:1: ( '{' )
            {
            // InternalQVTbase.g:9251:1: ( '{' )
            // InternalQVTbase.g:9252:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getLeftCurlyBracketKeyword_6_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getLeftCurlyBracketKeyword_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_6__1"
    // InternalQVTbase.g:9265:1: rule__ReferenceCS__Group_6__1 : rule__ReferenceCS__Group_6__1__Impl rule__ReferenceCS__Group_6__2 ;
    public final void rule__ReferenceCS__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9269:1: ( rule__ReferenceCS__Group_6__1__Impl rule__ReferenceCS__Group_6__2 )
            // InternalQVTbase.g:9270:2: rule__ReferenceCS__Group_6__1__Impl rule__ReferenceCS__Group_6__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__ReferenceCS__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_6__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__1"


    // $ANTLR start "rule__ReferenceCS__Group_6__1__Impl"
    // InternalQVTbase.g:9277:1: rule__ReferenceCS__Group_6__1__Impl : ( ( ( rule__ReferenceCS__Group_6_1__0 ) ) ( ( rule__ReferenceCS__Group_6_1__0 )* ) ) ;
    public final void rule__ReferenceCS__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9281:1: ( ( ( ( rule__ReferenceCS__Group_6_1__0 ) ) ( ( rule__ReferenceCS__Group_6_1__0 )* ) ) )
            // InternalQVTbase.g:9282:1: ( ( ( rule__ReferenceCS__Group_6_1__0 ) ) ( ( rule__ReferenceCS__Group_6_1__0 )* ) )
            {
            // InternalQVTbase.g:9282:1: ( ( ( rule__ReferenceCS__Group_6_1__0 ) ) ( ( rule__ReferenceCS__Group_6_1__0 )* ) )
            // InternalQVTbase.g:9283:1: ( ( rule__ReferenceCS__Group_6_1__0 ) ) ( ( rule__ReferenceCS__Group_6_1__0 )* )
            {
            // InternalQVTbase.g:9283:1: ( ( rule__ReferenceCS__Group_6_1__0 ) )
            // InternalQVTbase.g:9284:1: ( rule__ReferenceCS__Group_6_1__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_6_1());
            }
            // InternalQVTbase.g:9285:1: ( rule__ReferenceCS__Group_6_1__0 )
            // InternalQVTbase.g:9285:2: rule__ReferenceCS__Group_6_1__0
            {
            pushFollow(FollowSets000.FOLLOW_45);
            rule__ReferenceCS__Group_6_1__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_6_1());
            }

            }

            // InternalQVTbase.g:9288:1: ( ( rule__ReferenceCS__Group_6_1__0 )* )
            // InternalQVTbase.g:9289:1: ( rule__ReferenceCS__Group_6_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getGroup_6_1());
            }
            // InternalQVTbase.g:9290:1: ( rule__ReferenceCS__Group_6_1__0 )*
            loop110:
            do {
                int alt110=2;
                int LA110_0 = input.LA(1);

                if ( ((LA110_0>=101 && LA110_0<=102)||(LA110_0>=105 && LA110_0<=116)||(LA110_0>=119 && LA110_0<=122)) ) {
                    alt110=1;
                }


                switch (alt110) {
            	case 1 :
            	    // InternalQVTbase.g:9290:2: rule__ReferenceCS__Group_6_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_45);
            	    rule__ReferenceCS__Group_6_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop110;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getGroup_6_1());
            }

            }


            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_6__2"
    // InternalQVTbase.g:9301:1: rule__ReferenceCS__Group_6__2 : rule__ReferenceCS__Group_6__2__Impl ;
    public final void rule__ReferenceCS__Group_6__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9305:1: ( rule__ReferenceCS__Group_6__2__Impl )
            // InternalQVTbase.g:9306:2: rule__ReferenceCS__Group_6__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_6__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__2"


    // $ANTLR start "rule__ReferenceCS__Group_6__2__Impl"
    // InternalQVTbase.g:9312:1: rule__ReferenceCS__Group_6__2__Impl : ( '}' ) ;
    public final void rule__ReferenceCS__Group_6__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9316:1: ( ( '}' ) )
            // InternalQVTbase.g:9317:1: ( '}' )
            {
            // InternalQVTbase.g:9317:1: ( '}' )
            // InternalQVTbase.g:9318:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getRightCurlyBracketKeyword_6_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getRightCurlyBracketKeyword_6_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6__2__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_6_1__0"
    // InternalQVTbase.g:9337:1: rule__ReferenceCS__Group_6_1__0 : rule__ReferenceCS__Group_6_1__0__Impl rule__ReferenceCS__Group_6_1__1 ;
    public final void rule__ReferenceCS__Group_6_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9341:1: ( rule__ReferenceCS__Group_6_1__0__Impl rule__ReferenceCS__Group_6_1__1 )
            // InternalQVTbase.g:9342:2: rule__ReferenceCS__Group_6_1__0__Impl rule__ReferenceCS__Group_6_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__ReferenceCS__Group_6_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_6_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6_1__0"


    // $ANTLR start "rule__ReferenceCS__Group_6_1__0__Impl"
    // InternalQVTbase.g:9349:1: rule__ReferenceCS__Group_6_1__0__Impl : ( ( rule__ReferenceCS__Alternatives_6_1_0 ) ) ;
    public final void rule__ReferenceCS__Group_6_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9353:1: ( ( ( rule__ReferenceCS__Alternatives_6_1_0 ) ) )
            // InternalQVTbase.g:9354:1: ( ( rule__ReferenceCS__Alternatives_6_1_0 ) )
            {
            // InternalQVTbase.g:9354:1: ( ( rule__ReferenceCS__Alternatives_6_1_0 ) )
            // InternalQVTbase.g:9355:1: ( rule__ReferenceCS__Alternatives_6_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getAlternatives_6_1_0());
            }
            // InternalQVTbase.g:9356:1: ( rule__ReferenceCS__Alternatives_6_1_0 )
            // InternalQVTbase.g:9356:2: rule__ReferenceCS__Alternatives_6_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Alternatives_6_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getAlternatives_6_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6_1__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_6_1__1"
    // InternalQVTbase.g:9366:1: rule__ReferenceCS__Group_6_1__1 : rule__ReferenceCS__Group_6_1__1__Impl ;
    public final void rule__ReferenceCS__Group_6_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9370:1: ( rule__ReferenceCS__Group_6_1__1__Impl )
            // InternalQVTbase.g:9371:2: rule__ReferenceCS__Group_6_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_6_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6_1__1"


    // $ANTLR start "rule__ReferenceCS__Group_6_1__1__Impl"
    // InternalQVTbase.g:9377:1: rule__ReferenceCS__Group_6_1__1__Impl : ( ( ',' )? ) ;
    public final void rule__ReferenceCS__Group_6_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9381:1: ( ( ( ',' )? ) )
            // InternalQVTbase.g:9382:1: ( ( ',' )? )
            {
            // InternalQVTbase.g:9382:1: ( ( ',' )? )
            // InternalQVTbase.g:9383:1: ( ',' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getCommaKeyword_6_1_1());
            }
            // InternalQVTbase.g:9384:1: ( ',' )?
            int alt111=2;
            int LA111_0 = input.LA(1);

            if ( (LA111_0==64) ) {
                alt111=1;
            }
            switch (alt111) {
                case 1 :
                    // InternalQVTbase.g:9385:2: ','
                    {
                    match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getCommaKeyword_6_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_6_1__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__0"
    // InternalQVTbase.g:9400:1: rule__ReferenceCS__Group_7_0__0 : rule__ReferenceCS__Group_7_0__0__Impl rule__ReferenceCS__Group_7_0__1 ;
    public final void rule__ReferenceCS__Group_7_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9404:1: ( rule__ReferenceCS__Group_7_0__0__Impl rule__ReferenceCS__Group_7_0__1 )
            // InternalQVTbase.g:9405:2: rule__ReferenceCS__Group_7_0__0__Impl rule__ReferenceCS__Group_7_0__1
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__ReferenceCS__Group_7_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__0"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__0__Impl"
    // InternalQVTbase.g:9412:1: rule__ReferenceCS__Group_7_0__0__Impl : ( '{' ) ;
    public final void rule__ReferenceCS__Group_7_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9416:1: ( ( '{' ) )
            // InternalQVTbase.g:9417:1: ( '{' )
            {
            // InternalQVTbase.g:9417:1: ( '{' )
            // InternalQVTbase.g:9418:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getLeftCurlyBracketKeyword_7_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getLeftCurlyBracketKeyword_7_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__1"
    // InternalQVTbase.g:9431:1: rule__ReferenceCS__Group_7_0__1 : rule__ReferenceCS__Group_7_0__1__Impl rule__ReferenceCS__Group_7_0__2 ;
    public final void rule__ReferenceCS__Group_7_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9435:1: ( rule__ReferenceCS__Group_7_0__1__Impl rule__ReferenceCS__Group_7_0__2 )
            // InternalQVTbase.g:9436:2: rule__ReferenceCS__Group_7_0__1__Impl rule__ReferenceCS__Group_7_0__2
            {
            pushFollow(FollowSets000.FOLLOW_15);
            rule__ReferenceCS__Group_7_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__1"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__1__Impl"
    // InternalQVTbase.g:9443:1: rule__ReferenceCS__Group_7_0__1__Impl : ( ( rule__ReferenceCS__Alternatives_7_0_1 )* ) ;
    public final void rule__ReferenceCS__Group_7_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9447:1: ( ( ( rule__ReferenceCS__Alternatives_7_0_1 )* ) )
            // InternalQVTbase.g:9448:1: ( ( rule__ReferenceCS__Alternatives_7_0_1 )* )
            {
            // InternalQVTbase.g:9448:1: ( ( rule__ReferenceCS__Alternatives_7_0_1 )* )
            // InternalQVTbase.g:9449:1: ( rule__ReferenceCS__Alternatives_7_0_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getAlternatives_7_0_1());
            }
            // InternalQVTbase.g:9450:1: ( rule__ReferenceCS__Alternatives_7_0_1 )*
            loop112:
            do {
                int alt112=2;
                int LA112_0 = input.LA(1);

                if ( ((LA112_0>=65 && LA112_0<=66)) ) {
                    alt112=1;
                }


                switch (alt112) {
            	case 1 :
            	    // InternalQVTbase.g:9450:2: rule__ReferenceCS__Alternatives_7_0_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_16);
            	    rule__ReferenceCS__Alternatives_7_0_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop112;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getAlternatives_7_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__2"
    // InternalQVTbase.g:9460:1: rule__ReferenceCS__Group_7_0__2 : rule__ReferenceCS__Group_7_0__2__Impl ;
    public final void rule__ReferenceCS__Group_7_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9464:1: ( rule__ReferenceCS__Group_7_0__2__Impl )
            // InternalQVTbase.g:9465:2: rule__ReferenceCS__Group_7_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__2"


    // $ANTLR start "rule__ReferenceCS__Group_7_0__2__Impl"
    // InternalQVTbase.g:9471:1: rule__ReferenceCS__Group_7_0__2__Impl : ( '}' ) ;
    public final void rule__ReferenceCS__Group_7_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9475:1: ( ( '}' ) )
            // InternalQVTbase.g:9476:1: ( '}' )
            {
            // InternalQVTbase.g:9476:1: ( '}' )
            // InternalQVTbase.g:9477:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getRightCurlyBracketKeyword_7_0_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getRightCurlyBracketKeyword_7_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0__2__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__0"
    // InternalQVTbase.g:9496:1: rule__ReferenceCS__Group_7_0_1_0__0 : rule__ReferenceCS__Group_7_0_1_0__0__Impl rule__ReferenceCS__Group_7_0_1_0__1 ;
    public final void rule__ReferenceCS__Group_7_0_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9500:1: ( rule__ReferenceCS__Group_7_0_1_0__0__Impl rule__ReferenceCS__Group_7_0_1_0__1 )
            // InternalQVTbase.g:9501:2: rule__ReferenceCS__Group_7_0_1_0__0__Impl rule__ReferenceCS__Group_7_0_1_0__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__ReferenceCS__Group_7_0_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__0"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__0__Impl"
    // InternalQVTbase.g:9508:1: rule__ReferenceCS__Group_7_0_1_0__0__Impl : ( 'initial' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9512:1: ( ( 'initial' ) )
            // InternalQVTbase.g:9513:1: ( 'initial' )
            {
            // InternalQVTbase.g:9513:1: ( 'initial' )
            // InternalQVTbase.g:9514:1: 'initial'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getInitialKeyword_7_0_1_0_0());
            }
            match(input,65,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getInitialKeyword_7_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__1"
    // InternalQVTbase.g:9527:1: rule__ReferenceCS__Group_7_0_1_0__1 : rule__ReferenceCS__Group_7_0_1_0__1__Impl rule__ReferenceCS__Group_7_0_1_0__2 ;
    public final void rule__ReferenceCS__Group_7_0_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9531:1: ( rule__ReferenceCS__Group_7_0_1_0__1__Impl rule__ReferenceCS__Group_7_0_1_0__2 )
            // InternalQVTbase.g:9532:2: rule__ReferenceCS__Group_7_0_1_0__1__Impl rule__ReferenceCS__Group_7_0_1_0__2
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__ReferenceCS__Group_7_0_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__1"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__1__Impl"
    // InternalQVTbase.g:9539:1: rule__ReferenceCS__Group_7_0_1_0__1__Impl : ( ( ruleUnrestrictedName )? ) ;
    public final void rule__ReferenceCS__Group_7_0_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9543:1: ( ( ( ruleUnrestrictedName )? ) )
            // InternalQVTbase.g:9544:1: ( ( ruleUnrestrictedName )? )
            {
            // InternalQVTbase.g:9544:1: ( ( ruleUnrestrictedName )? )
            // InternalQVTbase.g:9545:1: ( ruleUnrestrictedName )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getUnrestrictedNameParserRuleCall_7_0_1_0_1());
            }
            // InternalQVTbase.g:9546:1: ( ruleUnrestrictedName )?
            int alt113=2;
            int LA113_0 = input.LA(1);

            if ( ((LA113_0>=RULE_SIMPLE_ID && LA113_0<=RULE_ESCAPED_ID)) ) {
                alt113=1;
            }
            switch (alt113) {
                case 1 :
                    // InternalQVTbase.g:9546:3: ruleUnrestrictedName
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getUnrestrictedNameParserRuleCall_7_0_1_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__2"
    // InternalQVTbase.g:9556:1: rule__ReferenceCS__Group_7_0_1_0__2 : rule__ReferenceCS__Group_7_0_1_0__2__Impl rule__ReferenceCS__Group_7_0_1_0__3 ;
    public final void rule__ReferenceCS__Group_7_0_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9560:1: ( rule__ReferenceCS__Group_7_0_1_0__2__Impl rule__ReferenceCS__Group_7_0_1_0__3 )
            // InternalQVTbase.g:9561:2: rule__ReferenceCS__Group_7_0_1_0__2__Impl rule__ReferenceCS__Group_7_0_1_0__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ReferenceCS__Group_7_0_1_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_0__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__2"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__2__Impl"
    // InternalQVTbase.g:9568:1: rule__ReferenceCS__Group_7_0_1_0__2__Impl : ( ':' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9572:1: ( ( ':' ) )
            // InternalQVTbase.g:9573:1: ( ':' )
            {
            // InternalQVTbase.g:9573:1: ( ':' )
            // InternalQVTbase.g:9574:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getColonKeyword_7_0_1_0_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getColonKeyword_7_0_1_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__2__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__3"
    // InternalQVTbase.g:9587:1: rule__ReferenceCS__Group_7_0_1_0__3 : rule__ReferenceCS__Group_7_0_1_0__3__Impl rule__ReferenceCS__Group_7_0_1_0__4 ;
    public final void rule__ReferenceCS__Group_7_0_1_0__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9591:1: ( rule__ReferenceCS__Group_7_0_1_0__3__Impl rule__ReferenceCS__Group_7_0_1_0__4 )
            // InternalQVTbase.g:9592:2: rule__ReferenceCS__Group_7_0_1_0__3__Impl rule__ReferenceCS__Group_7_0_1_0__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ReferenceCS__Group_7_0_1_0__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_0__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__3"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__3__Impl"
    // InternalQVTbase.g:9599:1: rule__ReferenceCS__Group_7_0_1_0__3__Impl : ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )? ) ;
    public final void rule__ReferenceCS__Group_7_0_1_0__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9603:1: ( ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )? ) )
            // InternalQVTbase.g:9604:1: ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )? )
            {
            // InternalQVTbase.g:9604:1: ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )? )
            // InternalQVTbase.g:9605:1: ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsAssignment_7_0_1_0_3());
            }
            // InternalQVTbase.g:9606:1: ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 )?
            int alt114=2;
            int LA114_0 = input.LA(1);

            if ( ((LA114_0>=RULE_INT && LA114_0<=RULE_UNQUOTED_STRING)||(LA114_0>=19 && LA114_0<=22)||(LA114_0>=43 && LA114_0<=57)||LA114_0==71||LA114_0==82||(LA114_0>=84 && LA114_0<=85)||LA114_0==90||(LA114_0>=95 && LA114_0<=96)||(LA114_0>=128 && LA114_0<=129)) ) {
                alt114=1;
            }
            switch (alt114) {
                case 1 :
                    // InternalQVTbase.g:9606:2: rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsAssignment_7_0_1_0_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__3__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__4"
    // InternalQVTbase.g:9616:1: rule__ReferenceCS__Group_7_0_1_0__4 : rule__ReferenceCS__Group_7_0_1_0__4__Impl ;
    public final void rule__ReferenceCS__Group_7_0_1_0__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9620:1: ( rule__ReferenceCS__Group_7_0_1_0__4__Impl )
            // InternalQVTbase.g:9621:2: rule__ReferenceCS__Group_7_0_1_0__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_0__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__4"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_0__4__Impl"
    // InternalQVTbase.g:9627:1: rule__ReferenceCS__Group_7_0_1_0__4__Impl : ( ';' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_0__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9631:1: ( ( ';' ) )
            // InternalQVTbase.g:9632:1: ( ';' )
            {
            // InternalQVTbase.g:9632:1: ( ';' )
            // InternalQVTbase.g:9633:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_0_1_0_4());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_0_1_0_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_0__4__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__0"
    // InternalQVTbase.g:9656:1: rule__ReferenceCS__Group_7_0_1_1__0 : rule__ReferenceCS__Group_7_0_1_1__0__Impl rule__ReferenceCS__Group_7_0_1_1__1 ;
    public final void rule__ReferenceCS__Group_7_0_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9660:1: ( rule__ReferenceCS__Group_7_0_1_1__0__Impl rule__ReferenceCS__Group_7_0_1_1__1 )
            // InternalQVTbase.g:9661:2: rule__ReferenceCS__Group_7_0_1_1__0__Impl rule__ReferenceCS__Group_7_0_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__ReferenceCS__Group_7_0_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__0"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__0__Impl"
    // InternalQVTbase.g:9668:1: rule__ReferenceCS__Group_7_0_1_1__0__Impl : ( 'derivation' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9672:1: ( ( 'derivation' ) )
            // InternalQVTbase.g:9673:1: ( 'derivation' )
            {
            // InternalQVTbase.g:9673:1: ( 'derivation' )
            // InternalQVTbase.g:9674:1: 'derivation'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getDerivationKeyword_7_0_1_1_0());
            }
            match(input,66,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getDerivationKeyword_7_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__0__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__1"
    // InternalQVTbase.g:9687:1: rule__ReferenceCS__Group_7_0_1_1__1 : rule__ReferenceCS__Group_7_0_1_1__1__Impl rule__ReferenceCS__Group_7_0_1_1__2 ;
    public final void rule__ReferenceCS__Group_7_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9691:1: ( rule__ReferenceCS__Group_7_0_1_1__1__Impl rule__ReferenceCS__Group_7_0_1_1__2 )
            // InternalQVTbase.g:9692:2: rule__ReferenceCS__Group_7_0_1_1__1__Impl rule__ReferenceCS__Group_7_0_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_17);
            rule__ReferenceCS__Group_7_0_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__1"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__1__Impl"
    // InternalQVTbase.g:9699:1: rule__ReferenceCS__Group_7_0_1_1__1__Impl : ( ( ruleUnrestrictedName )? ) ;
    public final void rule__ReferenceCS__Group_7_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9703:1: ( ( ( ruleUnrestrictedName )? ) )
            // InternalQVTbase.g:9704:1: ( ( ruleUnrestrictedName )? )
            {
            // InternalQVTbase.g:9704:1: ( ( ruleUnrestrictedName )? )
            // InternalQVTbase.g:9705:1: ( ruleUnrestrictedName )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getUnrestrictedNameParserRuleCall_7_0_1_1_1());
            }
            // InternalQVTbase.g:9706:1: ( ruleUnrestrictedName )?
            int alt115=2;
            int LA115_0 = input.LA(1);

            if ( ((LA115_0>=RULE_SIMPLE_ID && LA115_0<=RULE_ESCAPED_ID)) ) {
                alt115=1;
            }
            switch (alt115) {
                case 1 :
                    // InternalQVTbase.g:9706:3: ruleUnrestrictedName
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    ruleUnrestrictedName();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getUnrestrictedNameParserRuleCall_7_0_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__1__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__2"
    // InternalQVTbase.g:9716:1: rule__ReferenceCS__Group_7_0_1_1__2 : rule__ReferenceCS__Group_7_0_1_1__2__Impl rule__ReferenceCS__Group_7_0_1_1__3 ;
    public final void rule__ReferenceCS__Group_7_0_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9720:1: ( rule__ReferenceCS__Group_7_0_1_1__2__Impl rule__ReferenceCS__Group_7_0_1_1__3 )
            // InternalQVTbase.g:9721:2: rule__ReferenceCS__Group_7_0_1_1__2__Impl rule__ReferenceCS__Group_7_0_1_1__3
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ReferenceCS__Group_7_0_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__2"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__2__Impl"
    // InternalQVTbase.g:9728:1: rule__ReferenceCS__Group_7_0_1_1__2__Impl : ( ':' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9732:1: ( ( ':' ) )
            // InternalQVTbase.g:9733:1: ( ':' )
            {
            // InternalQVTbase.g:9733:1: ( ':' )
            // InternalQVTbase.g:9734:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getColonKeyword_7_0_1_1_2());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getColonKeyword_7_0_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__2__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__3"
    // InternalQVTbase.g:9747:1: rule__ReferenceCS__Group_7_0_1_1__3 : rule__ReferenceCS__Group_7_0_1_1__3__Impl rule__ReferenceCS__Group_7_0_1_1__4 ;
    public final void rule__ReferenceCS__Group_7_0_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9751:1: ( rule__ReferenceCS__Group_7_0_1_1__3__Impl rule__ReferenceCS__Group_7_0_1_1__4 )
            // InternalQVTbase.g:9752:2: rule__ReferenceCS__Group_7_0_1_1__3__Impl rule__ReferenceCS__Group_7_0_1_1__4
            {
            pushFollow(FollowSets000.FOLLOW_18);
            rule__ReferenceCS__Group_7_0_1_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_1__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__3"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__3__Impl"
    // InternalQVTbase.g:9759:1: rule__ReferenceCS__Group_7_0_1_1__3__Impl : ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )? ) ;
    public final void rule__ReferenceCS__Group_7_0_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9763:1: ( ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )? ) )
            // InternalQVTbase.g:9764:1: ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )? )
            {
            // InternalQVTbase.g:9764:1: ( ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )? )
            // InternalQVTbase.g:9765:1: ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsAssignment_7_0_1_1_3());
            }
            // InternalQVTbase.g:9766:1: ( rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 )?
            int alt116=2;
            int LA116_0 = input.LA(1);

            if ( ((LA116_0>=RULE_INT && LA116_0<=RULE_UNQUOTED_STRING)||(LA116_0>=19 && LA116_0<=22)||(LA116_0>=43 && LA116_0<=57)||LA116_0==71||LA116_0==82||(LA116_0>=84 && LA116_0<=85)||LA116_0==90||(LA116_0>=95 && LA116_0<=96)||(LA116_0>=128 && LA116_0<=129)) ) {
                alt116=1;
            }
            switch (alt116) {
                case 1 :
                    // InternalQVTbase.g:9766:2: rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsAssignment_7_0_1_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__3__Impl"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__4"
    // InternalQVTbase.g:9776:1: rule__ReferenceCS__Group_7_0_1_1__4 : rule__ReferenceCS__Group_7_0_1_1__4__Impl ;
    public final void rule__ReferenceCS__Group_7_0_1_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9780:1: ( rule__ReferenceCS__Group_7_0_1_1__4__Impl )
            // InternalQVTbase.g:9781:2: rule__ReferenceCS__Group_7_0_1_1__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ReferenceCS__Group_7_0_1_1__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__4"


    // $ANTLR start "rule__ReferenceCS__Group_7_0_1_1__4__Impl"
    // InternalQVTbase.g:9787:1: rule__ReferenceCS__Group_7_0_1_1__4__Impl : ( ';' ) ;
    public final void rule__ReferenceCS__Group_7_0_1_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9791:1: ( ( ';' ) )
            // InternalQVTbase.g:9792:1: ( ';' )
            {
            // InternalQVTbase.g:9792:1: ( ';' )
            // InternalQVTbase.g:9793:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_0_1_1_4());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getSemicolonKeyword_7_0_1_1_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__Group_7_0_1_1__4__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__0"
    // InternalQVTbase.g:9816:1: rule__SimpleTargetElementCS__Group__0 : rule__SimpleTargetElementCS__Group__0__Impl rule__SimpleTargetElementCS__Group__1 ;
    public final void rule__SimpleTargetElementCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9820:1: ( rule__SimpleTargetElementCS__Group__0__Impl rule__SimpleTargetElementCS__Group__1 )
            // InternalQVTbase.g:9821:2: rule__SimpleTargetElementCS__Group__0__Impl rule__SimpleTargetElementCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__SimpleTargetElementCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__0"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__0__Impl"
    // InternalQVTbase.g:9828:1: rule__SimpleTargetElementCS__Group__0__Impl : ( ( rule__SimpleTargetElementCS__Alternatives_0 ) ) ;
    public final void rule__SimpleTargetElementCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9832:1: ( ( ( rule__SimpleTargetElementCS__Alternatives_0 ) ) )
            // InternalQVTbase.g:9833:1: ( ( rule__SimpleTargetElementCS__Alternatives_0 ) )
            {
            // InternalQVTbase.g:9833:1: ( ( rule__SimpleTargetElementCS__Alternatives_0 ) )
            // InternalQVTbase.g:9834:1: ( rule__SimpleTargetElementCS__Alternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getAlternatives_0());
            }
            // InternalQVTbase.g:9835:1: ( rule__SimpleTargetElementCS__Alternatives_0 )
            // InternalQVTbase.g:9835:2: rule__SimpleTargetElementCS__Alternatives_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Alternatives_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__0__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__1"
    // InternalQVTbase.g:9845:1: rule__SimpleTargetElementCS__Group__1 : rule__SimpleTargetElementCS__Group__1__Impl rule__SimpleTargetElementCS__Group__2 ;
    public final void rule__SimpleTargetElementCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9849:1: ( rule__SimpleTargetElementCS__Group__1__Impl rule__SimpleTargetElementCS__Group__2 )
            // InternalQVTbase.g:9850:2: rule__SimpleTargetElementCS__Group__1__Impl rule__SimpleTargetElementCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_46);
            rule__SimpleTargetElementCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__1"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__1__Impl"
    // InternalQVTbase.g:9857:1: rule__SimpleTargetElementCS__Group__1__Impl : ( ( rule__SimpleTargetElementCS__TypedModelAssignment_1 ) ) ;
    public final void rule__SimpleTargetElementCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9861:1: ( ( ( rule__SimpleTargetElementCS__TypedModelAssignment_1 ) ) )
            // InternalQVTbase.g:9862:1: ( ( rule__SimpleTargetElementCS__TypedModelAssignment_1 ) )
            {
            // InternalQVTbase.g:9862:1: ( ( rule__SimpleTargetElementCS__TypedModelAssignment_1 ) )
            // InternalQVTbase.g:9863:1: ( rule__SimpleTargetElementCS__TypedModelAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelAssignment_1());
            }
            // InternalQVTbase.g:9864:1: ( rule__SimpleTargetElementCS__TypedModelAssignment_1 )
            // InternalQVTbase.g:9864:2: rule__SimpleTargetElementCS__TypedModelAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__TypedModelAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__1__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__2"
    // InternalQVTbase.g:9874:1: rule__SimpleTargetElementCS__Group__2 : rule__SimpleTargetElementCS__Group__2__Impl rule__SimpleTargetElementCS__Group__3 ;
    public final void rule__SimpleTargetElementCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9878:1: ( rule__SimpleTargetElementCS__Group__2__Impl rule__SimpleTargetElementCS__Group__3 )
            // InternalQVTbase.g:9879:2: rule__SimpleTargetElementCS__Group__2__Impl rule__SimpleTargetElementCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_46);
            rule__SimpleTargetElementCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__2"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__2__Impl"
    // InternalQVTbase.g:9886:1: rule__SimpleTargetElementCS__Group__2__Impl : ( ( rule__SimpleTargetElementCS__Group_2__0 )? ) ;
    public final void rule__SimpleTargetElementCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9890:1: ( ( ( rule__SimpleTargetElementCS__Group_2__0 )? ) )
            // InternalQVTbase.g:9891:1: ( ( rule__SimpleTargetElementCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:9891:1: ( ( rule__SimpleTargetElementCS__Group_2__0 )? )
            // InternalQVTbase.g:9892:1: ( rule__SimpleTargetElementCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:9893:1: ( rule__SimpleTargetElementCS__Group_2__0 )?
            int alt117=2;
            int LA117_0 = input.LA(1);

            if ( (LA117_0==77) ) {
                alt117=1;
            }
            switch (alt117) {
                case 1 :
                    // InternalQVTbase.g:9893:2: rule__SimpleTargetElementCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__2__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__3"
    // InternalQVTbase.g:9903:1: rule__SimpleTargetElementCS__Group__3 : rule__SimpleTargetElementCS__Group__3__Impl ;
    public final void rule__SimpleTargetElementCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9907:1: ( rule__SimpleTargetElementCS__Group__3__Impl )
            // InternalQVTbase.g:9908:2: rule__SimpleTargetElementCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__3"


    // $ANTLR start "rule__SimpleTargetElementCS__Group__3__Impl"
    // InternalQVTbase.g:9914:1: rule__SimpleTargetElementCS__Group__3__Impl : ( ';' ) ;
    public final void rule__SimpleTargetElementCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9918:1: ( ( ';' ) )
            // InternalQVTbase.g:9919:1: ( ';' )
            {
            // InternalQVTbase.g:9919:1: ( ';' )
            // InternalQVTbase.g:9920:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getSemicolonKeyword_3());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getSemicolonKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group__3__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2__0"
    // InternalQVTbase.g:9941:1: rule__SimpleTargetElementCS__Group_2__0 : rule__SimpleTargetElementCS__Group_2__0__Impl rule__SimpleTargetElementCS__Group_2__1 ;
    public final void rule__SimpleTargetElementCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9945:1: ( rule__SimpleTargetElementCS__Group_2__0__Impl rule__SimpleTargetElementCS__Group_2__1 )
            // InternalQVTbase.g:9946:2: rule__SimpleTargetElementCS__Group_2__0__Impl rule__SimpleTargetElementCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_47);
            rule__SimpleTargetElementCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2__0"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2__0__Impl"
    // InternalQVTbase.g:9953:1: rule__SimpleTargetElementCS__Group_2__0__Impl : ( 'iterates' ) ;
    public final void rule__SimpleTargetElementCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9957:1: ( ( 'iterates' ) )
            // InternalQVTbase.g:9958:1: ( 'iterates' )
            {
            // InternalQVTbase.g:9958:1: ( 'iterates' )
            // InternalQVTbase.g:9959:1: 'iterates'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesKeyword_2_0());
            }
            match(input,77,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2__0__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2__1"
    // InternalQVTbase.g:9972:1: rule__SimpleTargetElementCS__Group_2__1 : rule__SimpleTargetElementCS__Group_2__1__Impl ;
    public final void rule__SimpleTargetElementCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9976:1: ( rule__SimpleTargetElementCS__Group_2__1__Impl )
            // InternalQVTbase.g:9977:2: rule__SimpleTargetElementCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__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__SimpleTargetElementCS__Group_2__1"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2__1__Impl"
    // InternalQVTbase.g:9983:1: rule__SimpleTargetElementCS__Group_2__1__Impl : ( ( rule__SimpleTargetElementCS__Alternatives_2_1 ) ) ;
    public final void rule__SimpleTargetElementCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:9987:1: ( ( ( rule__SimpleTargetElementCS__Alternatives_2_1 ) ) )
            // InternalQVTbase.g:9988:1: ( ( rule__SimpleTargetElementCS__Alternatives_2_1 ) )
            {
            // InternalQVTbase.g:9988:1: ( ( rule__SimpleTargetElementCS__Alternatives_2_1 ) )
            // InternalQVTbase.g:9989:1: ( rule__SimpleTargetElementCS__Alternatives_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getAlternatives_2_1());
            }
            // InternalQVTbase.g:9990:1: ( rule__SimpleTargetElementCS__Alternatives_2_1 )
            // InternalQVTbase.g:9990:2: rule__SimpleTargetElementCS__Alternatives_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Alternatives_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getAlternatives_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2__1__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__0"
    // InternalQVTbase.g:10004:1: rule__SimpleTargetElementCS__Group_2_1_1__0 : rule__SimpleTargetElementCS__Group_2_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1__1 ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10008:1: ( rule__SimpleTargetElementCS__Group_2_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1__1 )
            // InternalQVTbase.g:10009:2: rule__SimpleTargetElementCS__Group_2_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_48);
            rule__SimpleTargetElementCS__Group_2_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__0"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__0__Impl"
    // InternalQVTbase.g:10016:1: rule__SimpleTargetElementCS__Group_2_1_1__0__Impl : ( '{' ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10020:1: ( ( '{' ) )
            // InternalQVTbase.g:10021:1: ( '{' )
            {
            // InternalQVTbase.g:10021:1: ( '{' )
            // InternalQVTbase.g:10022:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getLeftCurlyBracketKeyword_2_1_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getLeftCurlyBracketKeyword_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__0__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__1"
    // InternalQVTbase.g:10035:1: rule__SimpleTargetElementCS__Group_2_1_1__1 : rule__SimpleTargetElementCS__Group_2_1_1__1__Impl rule__SimpleTargetElementCS__Group_2_1_1__2 ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10039:1: ( rule__SimpleTargetElementCS__Group_2_1_1__1__Impl rule__SimpleTargetElementCS__Group_2_1_1__2 )
            // InternalQVTbase.g:10040:2: rule__SimpleTargetElementCS__Group_2_1_1__1__Impl rule__SimpleTargetElementCS__Group_2_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_48);
            rule__SimpleTargetElementCS__Group_2_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__1"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__1__Impl"
    // InternalQVTbase.g:10047:1: rule__SimpleTargetElementCS__Group_2_1_1__1__Impl : ( ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )? ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10051:1: ( ( ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )? ) )
            // InternalQVTbase.g:10052:1: ( ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )? )
            {
            // InternalQVTbase.g:10052:1: ( ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )? )
            // InternalQVTbase.g:10053:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1_1());
            }
            // InternalQVTbase.g:10054:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1__0 )?
            int alt118=2;
            int LA118_0 = input.LA(1);

            if ( ((LA118_0>=RULE_SIMPLE_ID && LA118_0<=RULE_ESCAPED_ID)) ) {
                alt118=1;
            }
            switch (alt118) {
                case 1 :
                    // InternalQVTbase.g:10054:2: rule__SimpleTargetElementCS__Group_2_1_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__SimpleTargetElementCS__Group_2_1_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__1__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__2"
    // InternalQVTbase.g:10064:1: rule__SimpleTargetElementCS__Group_2_1_1__2 : rule__SimpleTargetElementCS__Group_2_1_1__2__Impl ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10068:1: ( rule__SimpleTargetElementCS__Group_2_1_1__2__Impl )
            // InternalQVTbase.g:10069:2: rule__SimpleTargetElementCS__Group_2_1_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__2"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1__2__Impl"
    // InternalQVTbase.g:10075:1: rule__SimpleTargetElementCS__Group_2_1_1__2__Impl : ( '}' ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10079:1: ( ( '}' ) )
            // InternalQVTbase.g:10080:1: ( '}' )
            {
            // InternalQVTbase.g:10080:1: ( '}' )
            // InternalQVTbase.g:10081:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getRightCurlyBracketKeyword_2_1_1_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getRightCurlyBracketKeyword_2_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1__2__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1__0"
    // InternalQVTbase.g:10100:1: rule__SimpleTargetElementCS__Group_2_1_1_1__0 : rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1__1 ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10104:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1__1 )
            // InternalQVTbase.g:10105:2: rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1__0"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl"
    // InternalQVTbase.g:10112:1: rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl : ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 ) ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10116:1: ( ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 ) ) )
            // InternalQVTbase.g:10117:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 ) )
            {
            // InternalQVTbase.g:10117:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 ) )
            // InternalQVTbase.g:10118:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_1_1_0());
            }
            // InternalQVTbase.g:10119:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 )
            // InternalQVTbase.g:10119:2: rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1__0__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1__1"
    // InternalQVTbase.g:10129:1: rule__SimpleTargetElementCS__Group_2_1_1_1__1 : rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10133:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl )
            // InternalQVTbase.g:10134:2: rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1__1"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl"
    // InternalQVTbase.g:10140:1: rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl : ( ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )* ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10144:1: ( ( ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )* ) )
            // InternalQVTbase.g:10145:1: ( ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )* )
            {
            // InternalQVTbase.g:10145:1: ( ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )* )
            // InternalQVTbase.g:10146:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1_1_1());
            }
            // InternalQVTbase.g:10147:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 )*
            loop119:
            do {
                int alt119=2;
                int LA119_0 = input.LA(1);

                if ( (LA119_0==64) ) {
                    alt119=1;
                }


                switch (alt119) {
            	case 1 :
            	    // InternalQVTbase.g:10147:2: rule__SimpleTargetElementCS__Group_2_1_1_1_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__SimpleTargetElementCS__Group_2_1_1_1_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop119;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getGroup_2_1_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1__1__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1_1__0"
    // InternalQVTbase.g:10161:1: rule__SimpleTargetElementCS__Group_2_1_1_1_1__0 : rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1_1__1 ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10165:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1_1__1 )
            // InternalQVTbase.g:10166:2: rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl rule__SimpleTargetElementCS__Group_2_1_1_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1_1__0"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl"
    // InternalQVTbase.g:10173:1: rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl : ( ',' ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10177:1: ( ( ',' ) )
            // InternalQVTbase.g:10178:1: ( ',' )
            {
            // InternalQVTbase.g:10178:1: ( ',' )
            // InternalQVTbase.g:10179:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getCommaKeyword_2_1_1_1_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getCommaKeyword_2_1_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1_1__0__Impl"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1_1__1"
    // InternalQVTbase.g:10192:1: rule__SimpleTargetElementCS__Group_2_1_1_1_1__1 : rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10196:1: ( rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl )
            // InternalQVTbase.g:10197:2: rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1_1__1"


    // $ANTLR start "rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl"
    // InternalQVTbase.g:10203:1: rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl : ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 ) ) ;
    public final void rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10207:1: ( ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 ) ) )
            // InternalQVTbase.g:10208:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 ) )
            {
            // InternalQVTbase.g:10208:1: ( ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 ) )
            // InternalQVTbase.g:10209:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_1_1_1_1());
            }
            // InternalQVTbase.g:10210:1: ( rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 )
            // InternalQVTbase.g:10210:2: rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesAssignment_2_1_1_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__Group_2_1_1_1_1__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__0"
    // InternalQVTbase.g:10224:1: rule__StructuredClassCS__Group__0 : rule__StructuredClassCS__Group__0__Impl rule__StructuredClassCS__Group__1 ;
    public final void rule__StructuredClassCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10228:1: ( rule__StructuredClassCS__Group__0__Impl rule__StructuredClassCS__Group__1 )
            // InternalQVTbase.g:10229:2: rule__StructuredClassCS__Group__0__Impl rule__StructuredClassCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_49);
            rule__StructuredClassCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__0"


    // $ANTLR start "rule__StructuredClassCS__Group__0__Impl"
    // InternalQVTbase.g:10236:1: rule__StructuredClassCS__Group__0__Impl : ( ( rule__StructuredClassCS__IsAbstractAssignment_0 )? ) ;
    public final void rule__StructuredClassCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10240:1: ( ( ( rule__StructuredClassCS__IsAbstractAssignment_0 )? ) )
            // InternalQVTbase.g:10241:1: ( ( rule__StructuredClassCS__IsAbstractAssignment_0 )? )
            {
            // InternalQVTbase.g:10241:1: ( ( rule__StructuredClassCS__IsAbstractAssignment_0 )? )
            // InternalQVTbase.g:10242:1: ( rule__StructuredClassCS__IsAbstractAssignment_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsAbstractAssignment_0());
            }
            // InternalQVTbase.g:10243:1: ( rule__StructuredClassCS__IsAbstractAssignment_0 )?
            int alt120=2;
            int LA120_0 = input.LA(1);

            if ( (LA120_0==126) ) {
                alt120=1;
            }
            switch (alt120) {
                case 1 :
                    // InternalQVTbase.g:10243:2: rule__StructuredClassCS__IsAbstractAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__IsAbstractAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsAbstractAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__1"
    // InternalQVTbase.g:10253:1: rule__StructuredClassCS__Group__1 : rule__StructuredClassCS__Group__1__Impl rule__StructuredClassCS__Group__2 ;
    public final void rule__StructuredClassCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10257:1: ( rule__StructuredClassCS__Group__1__Impl rule__StructuredClassCS__Group__2 )
            // InternalQVTbase.g:10258:2: rule__StructuredClassCS__Group__1__Impl rule__StructuredClassCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__StructuredClassCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__1"


    // $ANTLR start "rule__StructuredClassCS__Group__1__Impl"
    // InternalQVTbase.g:10265:1: rule__StructuredClassCS__Group__1__Impl : ( 'class' ) ;
    public final void rule__StructuredClassCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10269:1: ( ( 'class' ) )
            // InternalQVTbase.g:10270:1: ( 'class' )
            {
            // InternalQVTbase.g:10270:1: ( 'class' )
            // InternalQVTbase.g:10271:1: 'class'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getClassKeyword_1());
            }
            match(input,78,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getClassKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__2"
    // InternalQVTbase.g:10284:1: rule__StructuredClassCS__Group__2 : rule__StructuredClassCS__Group__2__Impl rule__StructuredClassCS__Group__3 ;
    public final void rule__StructuredClassCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10288:1: ( rule__StructuredClassCS__Group__2__Impl rule__StructuredClassCS__Group__3 )
            // InternalQVTbase.g:10289:2: rule__StructuredClassCS__Group__2__Impl rule__StructuredClassCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__StructuredClassCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__2"


    // $ANTLR start "rule__StructuredClassCS__Group__2__Impl"
    // InternalQVTbase.g:10296:1: rule__StructuredClassCS__Group__2__Impl : ( ( rule__StructuredClassCS__NameAssignment_2 ) ) ;
    public final void rule__StructuredClassCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10300:1: ( ( ( rule__StructuredClassCS__NameAssignment_2 ) ) )
            // InternalQVTbase.g:10301:1: ( ( rule__StructuredClassCS__NameAssignment_2 ) )
            {
            // InternalQVTbase.g:10301:1: ( ( rule__StructuredClassCS__NameAssignment_2 ) )
            // InternalQVTbase.g:10302:1: ( rule__StructuredClassCS__NameAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getNameAssignment_2());
            }
            // InternalQVTbase.g:10303:1: ( rule__StructuredClassCS__NameAssignment_2 )
            // InternalQVTbase.g:10303:2: rule__StructuredClassCS__NameAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__NameAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getNameAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__2__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__3"
    // InternalQVTbase.g:10313:1: rule__StructuredClassCS__Group__3 : rule__StructuredClassCS__Group__3__Impl rule__StructuredClassCS__Group__4 ;
    public final void rule__StructuredClassCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10317:1: ( rule__StructuredClassCS__Group__3__Impl rule__StructuredClassCS__Group__4 )
            // InternalQVTbase.g:10318:2: rule__StructuredClassCS__Group__3__Impl rule__StructuredClassCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__StructuredClassCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__3"


    // $ANTLR start "rule__StructuredClassCS__Group__3__Impl"
    // InternalQVTbase.g:10325:1: rule__StructuredClassCS__Group__3__Impl : ( ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )? ) ;
    public final void rule__StructuredClassCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10329:1: ( ( ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )? ) )
            // InternalQVTbase.g:10330:1: ( ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )? )
            {
            // InternalQVTbase.g:10330:1: ( ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )? )
            // InternalQVTbase.g:10331:1: ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSignatureAssignment_3());
            }
            // InternalQVTbase.g:10332:1: ( rule__StructuredClassCS__OwnedSignatureAssignment_3 )?
            int alt121=2;
            int LA121_0 = input.LA(1);

            if ( (LA121_0==71) ) {
                alt121=1;
            }
            switch (alt121) {
                case 1 :
                    // InternalQVTbase.g:10332:2: rule__StructuredClassCS__OwnedSignatureAssignment_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__OwnedSignatureAssignment_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSignatureAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__3__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__4"
    // InternalQVTbase.g:10342:1: rule__StructuredClassCS__Group__4 : rule__StructuredClassCS__Group__4__Impl rule__StructuredClassCS__Group__5 ;
    public final void rule__StructuredClassCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10346:1: ( rule__StructuredClassCS__Group__4__Impl rule__StructuredClassCS__Group__5 )
            // InternalQVTbase.g:10347:2: rule__StructuredClassCS__Group__4__Impl rule__StructuredClassCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__StructuredClassCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__4"


    // $ANTLR start "rule__StructuredClassCS__Group__4__Impl"
    // InternalQVTbase.g:10354:1: rule__StructuredClassCS__Group__4__Impl : ( ( rule__StructuredClassCS__Group_4__0 )? ) ;
    public final void rule__StructuredClassCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10358:1: ( ( ( rule__StructuredClassCS__Group_4__0 )? ) )
            // InternalQVTbase.g:10359:1: ( ( rule__StructuredClassCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:10359:1: ( ( rule__StructuredClassCS__Group_4__0 )? )
            // InternalQVTbase.g:10360:1: ( rule__StructuredClassCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:10361:1: ( rule__StructuredClassCS__Group_4__0 )?
            int alt122=2;
            int LA122_0 = input.LA(1);

            if ( (LA122_0==79) ) {
                alt122=1;
            }
            switch (alt122) {
                case 1 :
                    // InternalQVTbase.g:10361:2: rule__StructuredClassCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__4__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__5"
    // InternalQVTbase.g:10371:1: rule__StructuredClassCS__Group__5 : rule__StructuredClassCS__Group__5__Impl rule__StructuredClassCS__Group__6 ;
    public final void rule__StructuredClassCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10375:1: ( rule__StructuredClassCS__Group__5__Impl rule__StructuredClassCS__Group__6 )
            // InternalQVTbase.g:10376:2: rule__StructuredClassCS__Group__5__Impl rule__StructuredClassCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__StructuredClassCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__5"


    // $ANTLR start "rule__StructuredClassCS__Group__5__Impl"
    // InternalQVTbase.g:10383:1: rule__StructuredClassCS__Group__5__Impl : ( ( rule__StructuredClassCS__Group_5__0 )? ) ;
    public final void rule__StructuredClassCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10387:1: ( ( ( rule__StructuredClassCS__Group_5__0 )? ) )
            // InternalQVTbase.g:10388:1: ( ( rule__StructuredClassCS__Group_5__0 )? )
            {
            // InternalQVTbase.g:10388:1: ( ( rule__StructuredClassCS__Group_5__0 )? )
            // InternalQVTbase.g:10389:1: ( rule__StructuredClassCS__Group_5__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getGroup_5());
            }
            // InternalQVTbase.g:10390:1: ( rule__StructuredClassCS__Group_5__0 )?
            int alt123=2;
            int LA123_0 = input.LA(1);

            if ( (LA123_0==61) ) {
                alt123=1;
            }
            switch (alt123) {
                case 1 :
                    // InternalQVTbase.g:10390:2: rule__StructuredClassCS__Group_5__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__Group_5__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getGroup_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__5__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__6"
    // InternalQVTbase.g:10400:1: rule__StructuredClassCS__Group__6 : rule__StructuredClassCS__Group__6__Impl rule__StructuredClassCS__Group__7 ;
    public final void rule__StructuredClassCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10404:1: ( rule__StructuredClassCS__Group__6__Impl rule__StructuredClassCS__Group__7 )
            // InternalQVTbase.g:10405:2: rule__StructuredClassCS__Group__6__Impl rule__StructuredClassCS__Group__7
            {
            pushFollow(FollowSets000.FOLLOW_50);
            rule__StructuredClassCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__6"


    // $ANTLR start "rule__StructuredClassCS__Group__6__Impl"
    // InternalQVTbase.g:10412:1: rule__StructuredClassCS__Group__6__Impl : ( ( rule__StructuredClassCS__Group_6__0 )? ) ;
    public final void rule__StructuredClassCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10416:1: ( ( ( rule__StructuredClassCS__Group_6__0 )? ) )
            // InternalQVTbase.g:10417:1: ( ( rule__StructuredClassCS__Group_6__0 )? )
            {
            // InternalQVTbase.g:10417:1: ( ( rule__StructuredClassCS__Group_6__0 )? )
            // InternalQVTbase.g:10418:1: ( rule__StructuredClassCS__Group_6__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getGroup_6());
            }
            // InternalQVTbase.g:10419:1: ( rule__StructuredClassCS__Group_6__0 )?
            int alt124=2;
            int LA124_0 = input.LA(1);

            if ( (LA124_0==62) ) {
                int LA124_1 = input.LA(2);

                if ( (LA124_1==127) ) {
                    alt124=1;
                }
                else if ( (LA124_1==63) ) {
                    int LA124_4 = input.LA(3);

                    if ( (LA124_4==17||LA124_4==62) ) {
                        alt124=1;
                    }
                }
            }
            switch (alt124) {
                case 1 :
                    // InternalQVTbase.g:10419:2: rule__StructuredClassCS__Group_6__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__Group_6__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getGroup_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__6__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group__7"
    // InternalQVTbase.g:10429:1: rule__StructuredClassCS__Group__7 : rule__StructuredClassCS__Group__7__Impl ;
    public final void rule__StructuredClassCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10433:1: ( rule__StructuredClassCS__Group__7__Impl )
            // InternalQVTbase.g:10434:2: rule__StructuredClassCS__Group__7__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__7"


    // $ANTLR start "rule__StructuredClassCS__Group__7__Impl"
    // InternalQVTbase.g:10440:1: rule__StructuredClassCS__Group__7__Impl : ( ( rule__StructuredClassCS__Alternatives_7 ) ) ;
    public final void rule__StructuredClassCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10444:1: ( ( ( rule__StructuredClassCS__Alternatives_7 ) ) )
            // InternalQVTbase.g:10445:1: ( ( rule__StructuredClassCS__Alternatives_7 ) )
            {
            // InternalQVTbase.g:10445:1: ( ( rule__StructuredClassCS__Alternatives_7 ) )
            // InternalQVTbase.g:10446:1: ( rule__StructuredClassCS__Alternatives_7 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getAlternatives_7());
            }
            // InternalQVTbase.g:10447:1: ( rule__StructuredClassCS__Alternatives_7 )
            // InternalQVTbase.g:10447:2: rule__StructuredClassCS__Alternatives_7
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Alternatives_7();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getAlternatives_7());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group__7__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_4__0"
    // InternalQVTbase.g:10473:1: rule__StructuredClassCS__Group_4__0 : rule__StructuredClassCS__Group_4__0__Impl rule__StructuredClassCS__Group_4__1 ;
    public final void rule__StructuredClassCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10477:1: ( rule__StructuredClassCS__Group_4__0__Impl rule__StructuredClassCS__Group_4__1 )
            // InternalQVTbase.g:10478:2: rule__StructuredClassCS__Group_4__0__Impl rule__StructuredClassCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__StructuredClassCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__0"


    // $ANTLR start "rule__StructuredClassCS__Group_4__0__Impl"
    // InternalQVTbase.g:10485:1: rule__StructuredClassCS__Group_4__0__Impl : ( 'extends' ) ;
    public final void rule__StructuredClassCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10489:1: ( ( 'extends' ) )
            // InternalQVTbase.g:10490:1: ( 'extends' )
            {
            // InternalQVTbase.g:10490:1: ( 'extends' )
            // InternalQVTbase.g:10491:1: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getExtendsKeyword_4_0());
            }
            match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getExtendsKeyword_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_4__1"
    // InternalQVTbase.g:10504:1: rule__StructuredClassCS__Group_4__1 : rule__StructuredClassCS__Group_4__1__Impl rule__StructuredClassCS__Group_4__2 ;
    public final void rule__StructuredClassCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10508:1: ( rule__StructuredClassCS__Group_4__1__Impl rule__StructuredClassCS__Group_4__2 )
            // InternalQVTbase.g:10509:2: rule__StructuredClassCS__Group_4__1__Impl rule__StructuredClassCS__Group_4__2
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__StructuredClassCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_4__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__1"


    // $ANTLR start "rule__StructuredClassCS__Group_4__1__Impl"
    // InternalQVTbase.g:10516:1: rule__StructuredClassCS__Group_4__1__Impl : ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 ) ) ;
    public final void rule__StructuredClassCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10520:1: ( ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 ) ) )
            // InternalQVTbase.g:10521:1: ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 ) )
            {
            // InternalQVTbase.g:10521:1: ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 ) )
            // InternalQVTbase.g:10522:1: ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesAssignment_4_1());
            }
            // InternalQVTbase.g:10523:1: ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 )
            // InternalQVTbase.g:10523:2: rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesAssignment_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_4__2"
    // InternalQVTbase.g:10533:1: rule__StructuredClassCS__Group_4__2 : rule__StructuredClassCS__Group_4__2__Impl ;
    public final void rule__StructuredClassCS__Group_4__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10537:1: ( rule__StructuredClassCS__Group_4__2__Impl )
            // InternalQVTbase.g:10538:2: rule__StructuredClassCS__Group_4__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_4__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__2"


    // $ANTLR start "rule__StructuredClassCS__Group_4__2__Impl"
    // InternalQVTbase.g:10544:1: rule__StructuredClassCS__Group_4__2__Impl : ( ( rule__StructuredClassCS__Group_4_2__0 )* ) ;
    public final void rule__StructuredClassCS__Group_4__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10548:1: ( ( ( rule__StructuredClassCS__Group_4_2__0 )* ) )
            // InternalQVTbase.g:10549:1: ( ( rule__StructuredClassCS__Group_4_2__0 )* )
            {
            // InternalQVTbase.g:10549:1: ( ( rule__StructuredClassCS__Group_4_2__0 )* )
            // InternalQVTbase.g:10550:1: ( rule__StructuredClassCS__Group_4_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getGroup_4_2());
            }
            // InternalQVTbase.g:10551:1: ( rule__StructuredClassCS__Group_4_2__0 )*
            loop125:
            do {
                int alt125=2;
                int LA125_0 = input.LA(1);

                if ( (LA125_0==64) ) {
                    alt125=1;
                }


                switch (alt125) {
            	case 1 :
            	    // InternalQVTbase.g:10551:2: rule__StructuredClassCS__Group_4_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__StructuredClassCS__Group_4_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop125;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getGroup_4_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4__2__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_4_2__0"
    // InternalQVTbase.g:10567:1: rule__StructuredClassCS__Group_4_2__0 : rule__StructuredClassCS__Group_4_2__0__Impl rule__StructuredClassCS__Group_4_2__1 ;
    public final void rule__StructuredClassCS__Group_4_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10571:1: ( rule__StructuredClassCS__Group_4_2__0__Impl rule__StructuredClassCS__Group_4_2__1 )
            // InternalQVTbase.g:10572:2: rule__StructuredClassCS__Group_4_2__0__Impl rule__StructuredClassCS__Group_4_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__StructuredClassCS__Group_4_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_4_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4_2__0"


    // $ANTLR start "rule__StructuredClassCS__Group_4_2__0__Impl"
    // InternalQVTbase.g:10579:1: rule__StructuredClassCS__Group_4_2__0__Impl : ( ',' ) ;
    public final void rule__StructuredClassCS__Group_4_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10583:1: ( ( ',' ) )
            // InternalQVTbase.g:10584:1: ( ',' )
            {
            // InternalQVTbase.g:10584:1: ( ',' )
            // InternalQVTbase.g:10585:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getCommaKeyword_4_2_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getCommaKeyword_4_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4_2__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_4_2__1"
    // InternalQVTbase.g:10598:1: rule__StructuredClassCS__Group_4_2__1 : rule__StructuredClassCS__Group_4_2__1__Impl ;
    public final void rule__StructuredClassCS__Group_4_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10602:1: ( rule__StructuredClassCS__Group_4_2__1__Impl )
            // InternalQVTbase.g:10603:2: rule__StructuredClassCS__Group_4_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_4_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4_2__1"


    // $ANTLR start "rule__StructuredClassCS__Group_4_2__1__Impl"
    // InternalQVTbase.g:10609:1: rule__StructuredClassCS__Group_4_2__1__Impl : ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 ) ) ;
    public final void rule__StructuredClassCS__Group_4_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10613:1: ( ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 ) ) )
            // InternalQVTbase.g:10614:1: ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 ) )
            {
            // InternalQVTbase.g:10614:1: ( ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 ) )
            // InternalQVTbase.g:10615:1: ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesAssignment_4_2_1());
            }
            // InternalQVTbase.g:10616:1: ( rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 )
            // InternalQVTbase.g:10616:2: rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesAssignment_4_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_4_2__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_5__0"
    // InternalQVTbase.g:10630:1: rule__StructuredClassCS__Group_5__0 : rule__StructuredClassCS__Group_5__0__Impl rule__StructuredClassCS__Group_5__1 ;
    public final void rule__StructuredClassCS__Group_5__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10634:1: ( rule__StructuredClassCS__Group_5__0__Impl rule__StructuredClassCS__Group_5__1 )
            // InternalQVTbase.g:10635:2: rule__StructuredClassCS__Group_5__0__Impl rule__StructuredClassCS__Group_5__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__StructuredClassCS__Group_5__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_5__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_5__0"


    // $ANTLR start "rule__StructuredClassCS__Group_5__0__Impl"
    // InternalQVTbase.g:10642:1: rule__StructuredClassCS__Group_5__0__Impl : ( ':' ) ;
    public final void rule__StructuredClassCS__Group_5__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10646:1: ( ( ':' ) )
            // InternalQVTbase.g:10647:1: ( ':' )
            {
            // InternalQVTbase.g:10647:1: ( ':' )
            // InternalQVTbase.g:10648:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getColonKeyword_5_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getColonKeyword_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_5__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_5__1"
    // InternalQVTbase.g:10661:1: rule__StructuredClassCS__Group_5__1 : rule__StructuredClassCS__Group_5__1__Impl ;
    public final void rule__StructuredClassCS__Group_5__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10665:1: ( rule__StructuredClassCS__Group_5__1__Impl )
            // InternalQVTbase.g:10666:2: rule__StructuredClassCS__Group_5__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_5__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_5__1"


    // $ANTLR start "rule__StructuredClassCS__Group_5__1__Impl"
    // InternalQVTbase.g:10672:1: rule__StructuredClassCS__Group_5__1__Impl : ( ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 ) ) ;
    public final void rule__StructuredClassCS__Group_5__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10676:1: ( ( ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 ) ) )
            // InternalQVTbase.g:10677:1: ( ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 ) )
            {
            // InternalQVTbase.g:10677:1: ( ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 ) )
            // InternalQVTbase.g:10678:1: ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getInstanceClassNameAssignment_5_1());
            }
            // InternalQVTbase.g:10679:1: ( rule__StructuredClassCS__InstanceClassNameAssignment_5_1 )
            // InternalQVTbase.g:10679:2: rule__StructuredClassCS__InstanceClassNameAssignment_5_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__InstanceClassNameAssignment_5_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getInstanceClassNameAssignment_5_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_5__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_6__0"
    // InternalQVTbase.g:10693:1: rule__StructuredClassCS__Group_6__0 : rule__StructuredClassCS__Group_6__0__Impl rule__StructuredClassCS__Group_6__1 ;
    public final void rule__StructuredClassCS__Group_6__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10697:1: ( rule__StructuredClassCS__Group_6__0__Impl rule__StructuredClassCS__Group_6__1 )
            // InternalQVTbase.g:10698:2: rule__StructuredClassCS__Group_6__0__Impl rule__StructuredClassCS__Group_6__1
            {
            pushFollow(FollowSets000.FOLLOW_51);
            rule__StructuredClassCS__Group_6__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_6__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__0"


    // $ANTLR start "rule__StructuredClassCS__Group_6__0__Impl"
    // InternalQVTbase.g:10705:1: rule__StructuredClassCS__Group_6__0__Impl : ( '{' ) ;
    public final void rule__StructuredClassCS__Group_6__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10709:1: ( ( '{' ) )
            // InternalQVTbase.g:10710:1: ( '{' )
            {
            // InternalQVTbase.g:10710:1: ( '{' )
            // InternalQVTbase.g:10711:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getLeftCurlyBracketKeyword_6_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getLeftCurlyBracketKeyword_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_6__1"
    // InternalQVTbase.g:10724:1: rule__StructuredClassCS__Group_6__1 : rule__StructuredClassCS__Group_6__1__Impl rule__StructuredClassCS__Group_6__2 ;
    public final void rule__StructuredClassCS__Group_6__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10728:1: ( rule__StructuredClassCS__Group_6__1__Impl rule__StructuredClassCS__Group_6__2 )
            // InternalQVTbase.g:10729:2: rule__StructuredClassCS__Group_6__1__Impl rule__StructuredClassCS__Group_6__2
            {
            pushFollow(FollowSets000.FOLLOW_51);
            rule__StructuredClassCS__Group_6__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_6__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__1"


    // $ANTLR start "rule__StructuredClassCS__Group_6__1__Impl"
    // InternalQVTbase.g:10736:1: rule__StructuredClassCS__Group_6__1__Impl : ( ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )? ) ;
    public final void rule__StructuredClassCS__Group_6__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10740:1: ( ( ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )? ) )
            // InternalQVTbase.g:10741:1: ( ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )? )
            {
            // InternalQVTbase.g:10741:1: ( ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )? )
            // InternalQVTbase.g:10742:1: ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsInterfaceAssignment_6_1());
            }
            // InternalQVTbase.g:10743:1: ( rule__StructuredClassCS__IsInterfaceAssignment_6_1 )?
            int alt126=2;
            int LA126_0 = input.LA(1);

            if ( (LA126_0==127) ) {
                alt126=1;
            }
            switch (alt126) {
                case 1 :
                    // InternalQVTbase.g:10743:2: rule__StructuredClassCS__IsInterfaceAssignment_6_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__StructuredClassCS__IsInterfaceAssignment_6_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsInterfaceAssignment_6_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_6__2"
    // InternalQVTbase.g:10753:1: rule__StructuredClassCS__Group_6__2 : rule__StructuredClassCS__Group_6__2__Impl ;
    public final void rule__StructuredClassCS__Group_6__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10757:1: ( rule__StructuredClassCS__Group_6__2__Impl )
            // InternalQVTbase.g:10758:2: rule__StructuredClassCS__Group_6__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_6__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__2"


    // $ANTLR start "rule__StructuredClassCS__Group_6__2__Impl"
    // InternalQVTbase.g:10764:1: rule__StructuredClassCS__Group_6__2__Impl : ( '}' ) ;
    public final void rule__StructuredClassCS__Group_6__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10768:1: ( ( '}' ) )
            // InternalQVTbase.g:10769:1: ( '}' )
            {
            // InternalQVTbase.g:10769:1: ( '}' )
            // InternalQVTbase.g:10770:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getRightCurlyBracketKeyword_6_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getRightCurlyBracketKeyword_6_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_6__2__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__0"
    // InternalQVTbase.g:10789:1: rule__StructuredClassCS__Group_7_0__0 : rule__StructuredClassCS__Group_7_0__0__Impl rule__StructuredClassCS__Group_7_0__1 ;
    public final void rule__StructuredClassCS__Group_7_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10793:1: ( rule__StructuredClassCS__Group_7_0__0__Impl rule__StructuredClassCS__Group_7_0__1 )
            // InternalQVTbase.g:10794:2: rule__StructuredClassCS__Group_7_0__0__Impl rule__StructuredClassCS__Group_7_0__1
            {
            pushFollow(FollowSets000.FOLLOW_52);
            rule__StructuredClassCS__Group_7_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_7_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__0"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__0__Impl"
    // InternalQVTbase.g:10801:1: rule__StructuredClassCS__Group_7_0__0__Impl : ( '{' ) ;
    public final void rule__StructuredClassCS__Group_7_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10805:1: ( ( '{' ) )
            // InternalQVTbase.g:10806:1: ( '{' )
            {
            // InternalQVTbase.g:10806:1: ( '{' )
            // InternalQVTbase.g:10807:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getLeftCurlyBracketKeyword_7_0_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getLeftCurlyBracketKeyword_7_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__0__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__1"
    // InternalQVTbase.g:10820:1: rule__StructuredClassCS__Group_7_0__1 : rule__StructuredClassCS__Group_7_0__1__Impl rule__StructuredClassCS__Group_7_0__2 ;
    public final void rule__StructuredClassCS__Group_7_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10824:1: ( rule__StructuredClassCS__Group_7_0__1__Impl rule__StructuredClassCS__Group_7_0__2 )
            // InternalQVTbase.g:10825:2: rule__StructuredClassCS__Group_7_0__1__Impl rule__StructuredClassCS__Group_7_0__2
            {
            pushFollow(FollowSets000.FOLLOW_52);
            rule__StructuredClassCS__Group_7_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_7_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__1"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__1__Impl"
    // InternalQVTbase.g:10832:1: rule__StructuredClassCS__Group_7_0__1__Impl : ( ( rule__StructuredClassCS__Alternatives_7_0_1 )* ) ;
    public final void rule__StructuredClassCS__Group_7_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10836:1: ( ( ( rule__StructuredClassCS__Alternatives_7_0_1 )* ) )
            // InternalQVTbase.g:10837:1: ( ( rule__StructuredClassCS__Alternatives_7_0_1 )* )
            {
            // InternalQVTbase.g:10837:1: ( ( rule__StructuredClassCS__Alternatives_7_0_1 )* )
            // InternalQVTbase.g:10838:1: ( rule__StructuredClassCS__Alternatives_7_0_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getAlternatives_7_0_1());
            }
            // InternalQVTbase.g:10839:1: ( rule__StructuredClassCS__Alternatives_7_0_1 )*
            loop127:
            do {
                int alt127=2;
                int LA127_0 = input.LA(1);

                if ( (LA127_0==60||LA127_0==70||LA127_0==75||(LA127_0>=99 && LA127_0<=100)) ) {
                    alt127=1;
                }


                switch (alt127) {
            	case 1 :
            	    // InternalQVTbase.g:10839:2: rule__StructuredClassCS__Alternatives_7_0_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_53);
            	    rule__StructuredClassCS__Alternatives_7_0_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop127;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getAlternatives_7_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__1__Impl"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__2"
    // InternalQVTbase.g:10849:1: rule__StructuredClassCS__Group_7_0__2 : rule__StructuredClassCS__Group_7_0__2__Impl ;
    public final void rule__StructuredClassCS__Group_7_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10853:1: ( rule__StructuredClassCS__Group_7_0__2__Impl )
            // InternalQVTbase.g:10854:2: rule__StructuredClassCS__Group_7_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__StructuredClassCS__Group_7_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__2"


    // $ANTLR start "rule__StructuredClassCS__Group_7_0__2__Impl"
    // InternalQVTbase.g:10860:1: rule__StructuredClassCS__Group_7_0__2__Impl : ( '}' ) ;
    public final void rule__StructuredClassCS__Group_7_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10864:1: ( ( '}' ) )
            // InternalQVTbase.g:10865:1: ( '}' )
            {
            // InternalQVTbase.g:10865:1: ( '}' )
            // InternalQVTbase.g:10866:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getRightCurlyBracketKeyword_7_0_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getRightCurlyBracketKeyword_7_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__Group_7_0__2__Impl"


    // $ANTLR start "rule__TypedMultiplicityRefCS__Group__0"
    // InternalQVTbase.g:10886:1: rule__TypedMultiplicityRefCS__Group__0 : rule__TypedMultiplicityRefCS__Group__0__Impl rule__TypedMultiplicityRefCS__Group__1 ;
    public final void rule__TypedMultiplicityRefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10890:1: ( rule__TypedMultiplicityRefCS__Group__0__Impl rule__TypedMultiplicityRefCS__Group__1 )
            // InternalQVTbase.g:10891:2: rule__TypedMultiplicityRefCS__Group__0__Impl rule__TypedMultiplicityRefCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_54);
            rule__TypedMultiplicityRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedMultiplicityRefCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedMultiplicityRefCS__Group__0"


    // $ANTLR start "rule__TypedMultiplicityRefCS__Group__0__Impl"
    // InternalQVTbase.g:10898:1: rule__TypedMultiplicityRefCS__Group__0__Impl : ( ruleTypedRefCS ) ;
    public final void rule__TypedMultiplicityRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10902:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:10903:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:10903:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:10904:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedMultiplicityRefCSAccess().getTypedRefCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedMultiplicityRefCSAccess().getTypedRefCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedMultiplicityRefCS__Group__0__Impl"


    // $ANTLR start "rule__TypedMultiplicityRefCS__Group__1"
    // InternalQVTbase.g:10915:1: rule__TypedMultiplicityRefCS__Group__1 : rule__TypedMultiplicityRefCS__Group__1__Impl ;
    public final void rule__TypedMultiplicityRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10919:1: ( rule__TypedMultiplicityRefCS__Group__1__Impl )
            // InternalQVTbase.g:10920:2: rule__TypedMultiplicityRefCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedMultiplicityRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedMultiplicityRefCS__Group__1"


    // $ANTLR start "rule__TypedMultiplicityRefCS__Group__1__Impl"
    // InternalQVTbase.g:10926:1: rule__TypedMultiplicityRefCS__Group__1__Impl : ( ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypedMultiplicityRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10930:1: ( ( ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalQVTbase.g:10931:1: ( ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalQVTbase.g:10931:1: ( ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )? )
            // InternalQVTbase.g:10932:1: ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedMultiplicityRefCSAccess().getOwnedMultiplicityAssignment_1());
            }
            // InternalQVTbase.g:10933:1: ( rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 )?
            int alt128=2;
            int LA128_0 = input.LA(1);

            if ( (LA128_0==87) ) {
                alt128=1;
            }
            switch (alt128) {
                case 1 :
                    // InternalQVTbase.g:10933:2: rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedMultiplicityRefCSAccess().getOwnedMultiplicityAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedMultiplicityRefCS__Group__1__Impl"


    // $ANTLR start "rule__SIGNED__Group__0"
    // InternalQVTbase.g:10947:1: rule__SIGNED__Group__0 : rule__SIGNED__Group__0__Impl rule__SIGNED__Group__1 ;
    public final void rule__SIGNED__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10951:1: ( rule__SIGNED__Group__0__Impl rule__SIGNED__Group__1 )
            // InternalQVTbase.g:10952:2: rule__SIGNED__Group__0__Impl rule__SIGNED__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_28);
            rule__SIGNED__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SIGNED__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SIGNED__Group__0"


    // $ANTLR start "rule__SIGNED__Group__0__Impl"
    // InternalQVTbase.g:10959:1: rule__SIGNED__Group__0__Impl : ( ( '-' )? ) ;
    public final void rule__SIGNED__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10963:1: ( ( ( '-' )? ) )
            // InternalQVTbase.g:10964:1: ( ( '-' )? )
            {
            // InternalQVTbase.g:10964:1: ( ( '-' )? )
            // InternalQVTbase.g:10965:1: ( '-' )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSIGNEDAccess().getHyphenMinusKeyword_0());
            }
            // InternalQVTbase.g:10966:1: ( '-' )?
            int alt129=2;
            int LA129_0 = input.LA(1);

            if ( (LA129_0==19) ) {
                alt129=1;
            }
            switch (alt129) {
                case 1 :
                    // InternalQVTbase.g:10967:2: '-'
                    {
                    match(input,19,FollowSets000.FOLLOW_2); if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSIGNEDAccess().getHyphenMinusKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SIGNED__Group__0__Impl"


    // $ANTLR start "rule__SIGNED__Group__1"
    // InternalQVTbase.g:10978:1: rule__SIGNED__Group__1 : rule__SIGNED__Group__1__Impl ;
    public final void rule__SIGNED__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10982:1: ( rule__SIGNED__Group__1__Impl )
            // InternalQVTbase.g:10983:2: rule__SIGNED__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SIGNED__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SIGNED__Group__1"


    // $ANTLR start "rule__SIGNED__Group__1__Impl"
    // InternalQVTbase.g:10989:1: rule__SIGNED__Group__1__Impl : ( RULE_INT ) ;
    public final void rule__SIGNED__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:10993:1: ( ( RULE_INT ) )
            // InternalQVTbase.g:10994:1: ( RULE_INT )
            {
            // InternalQVTbase.g:10994:1: ( RULE_INT )
            // InternalQVTbase.g:10995:1: RULE_INT
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSIGNEDAccess().getINTTerminalRuleCall_1());
            }
            match(input,RULE_INT,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSIGNEDAccess().getINTTerminalRuleCall_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SIGNED__Group__1__Impl"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0"
    // InternalQVTbase.g:11012:1: rule__URIFirstPathElementCS__Group_1__0 : rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 ;
    public final void rule__URIFirstPathElementCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11016:1: ( rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1 )
            // InternalQVTbase.g:11017:2: rule__URIFirstPathElementCS__Group_1__0__Impl rule__URIFirstPathElementCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_10);
            rule__URIFirstPathElementCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__0__Impl"
    // InternalQVTbase.g:11024:1: rule__URIFirstPathElementCS__Group_1__0__Impl : ( () ) ;
    public final void rule__URIFirstPathElementCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11028:1: ( ( () ) )
            // InternalQVTbase.g:11029:1: ( () )
            {
            // InternalQVTbase.g:11029:1: ( () )
            // InternalQVTbase.g:11030:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0());
            }
            // InternalQVTbase.g:11031:1: ()
            // InternalQVTbase.g:11033:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getPathElementWithURICSAction_1_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__0__Impl"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1"
    // InternalQVTbase.g:11043:1: rule__URIFirstPathElementCS__Group_1__1 : rule__URIFirstPathElementCS__Group_1__1__Impl ;
    public final void rule__URIFirstPathElementCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11047:1: ( rule__URIFirstPathElementCS__Group_1__1__Impl )
            // InternalQVTbase.g:11048:2: rule__URIFirstPathElementCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__1"


    // $ANTLR start "rule__URIFirstPathElementCS__Group_1__1__Impl"
    // InternalQVTbase.g:11054:1: rule__URIFirstPathElementCS__Group_1__1__Impl : ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) ;
    public final void rule__URIFirstPathElementCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11058:1: ( ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) ) )
            // InternalQVTbase.g:11059:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            {
            // InternalQVTbase.g:11059:1: ( ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 ) )
            // InternalQVTbase.g:11060:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1());
            }
            // InternalQVTbase.g:11061:1: ( rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 )
            // InternalQVTbase.g:11061:2: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__URIFirstPathElementCS__ReferredElementAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__Group_1__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group__0"
    // InternalQVTbase.g:11075:1: rule__CollectionTypeCS__Group__0 : rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 ;
    public final void rule__CollectionTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11079:1: ( rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1 )
            // InternalQVTbase.g:11080:2: rule__CollectionTypeCS__Group__0__Impl rule__CollectionTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__CollectionTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__0"


    // $ANTLR start "rule__CollectionTypeCS__Group__0__Impl"
    // InternalQVTbase.g:11087:1: rule__CollectionTypeCS__Group__0__Impl : ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) ;
    public final void rule__CollectionTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11091:1: ( ( ( rule__CollectionTypeCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:11092:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:11092:1: ( ( rule__CollectionTypeCS__NameAssignment_0 ) )
            // InternalQVTbase.g:11093:1: ( rule__CollectionTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:11094:1: ( rule__CollectionTypeCS__NameAssignment_0 )
            // InternalQVTbase.g:11094:2: rule__CollectionTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group__1"
    // InternalQVTbase.g:11104:1: rule__CollectionTypeCS__Group__1 : rule__CollectionTypeCS__Group__1__Impl ;
    public final void rule__CollectionTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11108:1: ( rule__CollectionTypeCS__Group__1__Impl )
            // InternalQVTbase.g:11109:2: rule__CollectionTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__1"


    // $ANTLR start "rule__CollectionTypeCS__Group__1__Impl"
    // InternalQVTbase.g:11115:1: rule__CollectionTypeCS__Group__1__Impl : ( ( rule__CollectionTypeCS__Group_1__0 )? ) ;
    public final void rule__CollectionTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11119:1: ( ( ( rule__CollectionTypeCS__Group_1__0 )? ) )
            // InternalQVTbase.g:11120:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:11120:1: ( ( rule__CollectionTypeCS__Group_1__0 )? )
            // InternalQVTbase.g:11121:1: ( rule__CollectionTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:11122:1: ( rule__CollectionTypeCS__Group_1__0 )?
            int alt130=2;
            int LA130_0 = input.LA(1);

            if ( (LA130_0==71) ) {
                alt130=1;
            }
            switch (alt130) {
                case 1 :
                    // InternalQVTbase.g:11122:2: rule__CollectionTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__0"
    // InternalQVTbase.g:11136:1: rule__CollectionTypeCS__Group_1__0 : rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 ;
    public final void rule__CollectionTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11140:1: ( rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1 )
            // InternalQVTbase.g:11141:2: rule__CollectionTypeCS__Group_1__0__Impl rule__CollectionTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__CollectionTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__0"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__0__Impl"
    // InternalQVTbase.g:11148:1: rule__CollectionTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__CollectionTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11152:1: ( ( '(' ) )
            // InternalQVTbase.g:11153:1: ( '(' )
            {
            // InternalQVTbase.g:11153:1: ( '(' )
            // InternalQVTbase.g:11154:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__1"
    // InternalQVTbase.g:11167:1: rule__CollectionTypeCS__Group_1__1 : rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 ;
    public final void rule__CollectionTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11171:1: ( rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2 )
            // InternalQVTbase.g:11172:2: rule__CollectionTypeCS__Group_1__1__Impl rule__CollectionTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_55);
            rule__CollectionTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__1"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__1__Impl"
    // InternalQVTbase.g:11179:1: rule__CollectionTypeCS__Group_1__1__Impl : ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__CollectionTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11183:1: ( ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:11184:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:11184:1: ( ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 ) )
            // InternalQVTbase.g:11185:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalQVTbase.g:11186:1: ( rule__CollectionTypeCS__OwnedTypeAssignment_1_1 )
            // InternalQVTbase.g:11186:2: rule__CollectionTypeCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__2"
    // InternalQVTbase.g:11196:1: rule__CollectionTypeCS__Group_1__2 : rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 ;
    public final void rule__CollectionTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11200:1: ( rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3 )
            // InternalQVTbase.g:11201:2: rule__CollectionTypeCS__Group_1__2__Impl rule__CollectionTypeCS__Group_1__3
            {
            pushFollow(FollowSets000.FOLLOW_55);
            rule__CollectionTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__2"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__2__Impl"
    // InternalQVTbase.g:11208:1: rule__CollectionTypeCS__Group_1__2__Impl : ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) ;
    public final void rule__CollectionTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11212:1: ( ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? ) )
            // InternalQVTbase.g:11213:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? )
            {
            // InternalQVTbase.g:11213:1: ( ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )? )
            // InternalQVTbase.g:11214:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2());
            }
            // InternalQVTbase.g:11215:1: ( rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 )?
            int alt131=2;
            int LA131_0 = input.LA(1);

            if ( (LA131_0==87) ) {
                alt131=1;
            }
            switch (alt131) {
                case 1 :
                    // InternalQVTbase.g:11215:2: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityAssignment_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__3"
    // InternalQVTbase.g:11225:1: rule__CollectionTypeCS__Group_1__3 : rule__CollectionTypeCS__Group_1__3__Impl ;
    public final void rule__CollectionTypeCS__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11229:1: ( rule__CollectionTypeCS__Group_1__3__Impl )
            // InternalQVTbase.g:11230:2: rule__CollectionTypeCS__Group_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionTypeCS__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__3"


    // $ANTLR start "rule__CollectionTypeCS__Group_1__3__Impl"
    // InternalQVTbase.g:11236:1: rule__CollectionTypeCS__Group_1__3__Impl : ( ')' ) ;
    public final void rule__CollectionTypeCS__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11240:1: ( ( ')' ) )
            // InternalQVTbase.g:11241:1: ( ')' )
            {
            // InternalQVTbase.g:11241:1: ( ')' )
            // InternalQVTbase.g:11242:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getRightParenthesisKeyword_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__Group_1__3__Impl"


    // $ANTLR start "rule__MapTypeCS__Group__0"
    // InternalQVTbase.g:11263:1: rule__MapTypeCS__Group__0 : rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 ;
    public final void rule__MapTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11267:1: ( rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1 )
            // InternalQVTbase.g:11268:2: rule__MapTypeCS__Group__0__Impl rule__MapTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__MapTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__0"


    // $ANTLR start "rule__MapTypeCS__Group__0__Impl"
    // InternalQVTbase.g:11275:1: rule__MapTypeCS__Group__0__Impl : ( ( rule__MapTypeCS__NameAssignment_0 ) ) ;
    public final void rule__MapTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11279:1: ( ( ( rule__MapTypeCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:11280:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:11280:1: ( ( rule__MapTypeCS__NameAssignment_0 ) )
            // InternalQVTbase.g:11281:1: ( rule__MapTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:11282:1: ( rule__MapTypeCS__NameAssignment_0 )
            // InternalQVTbase.g:11282:2: rule__MapTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__0__Impl"


    // $ANTLR start "rule__MapTypeCS__Group__1"
    // InternalQVTbase.g:11292:1: rule__MapTypeCS__Group__1 : rule__MapTypeCS__Group__1__Impl ;
    public final void rule__MapTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11296:1: ( rule__MapTypeCS__Group__1__Impl )
            // InternalQVTbase.g:11297:2: rule__MapTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__1"


    // $ANTLR start "rule__MapTypeCS__Group__1__Impl"
    // InternalQVTbase.g:11303:1: rule__MapTypeCS__Group__1__Impl : ( ( rule__MapTypeCS__Group_1__0 )? ) ;
    public final void rule__MapTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11307:1: ( ( ( rule__MapTypeCS__Group_1__0 )? ) )
            // InternalQVTbase.g:11308:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:11308:1: ( ( rule__MapTypeCS__Group_1__0 )? )
            // InternalQVTbase.g:11309:1: ( rule__MapTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:11310:1: ( rule__MapTypeCS__Group_1__0 )?
            int alt132=2;
            int LA132_0 = input.LA(1);

            if ( (LA132_0==71) ) {
                alt132=1;
            }
            switch (alt132) {
                case 1 :
                    // InternalQVTbase.g:11310:2: rule__MapTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MapTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group__1__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__0"
    // InternalQVTbase.g:11324:1: rule__MapTypeCS__Group_1__0 : rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 ;
    public final void rule__MapTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11328:1: ( rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1 )
            // InternalQVTbase.g:11329:2: rule__MapTypeCS__Group_1__0__Impl rule__MapTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__MapTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__0"


    // $ANTLR start "rule__MapTypeCS__Group_1__0__Impl"
    // InternalQVTbase.g:11336:1: rule__MapTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__MapTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11340:1: ( ( '(' ) )
            // InternalQVTbase.g:11341:1: ( '(' )
            {
            // InternalQVTbase.g:11341:1: ( '(' )
            // InternalQVTbase.g:11342:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__1"
    // InternalQVTbase.g:11355:1: rule__MapTypeCS__Group_1__1 : rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 ;
    public final void rule__MapTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11359:1: ( rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2 )
            // InternalQVTbase.g:11360:2: rule__MapTypeCS__Group_1__1__Impl rule__MapTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__MapTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__1"


    // $ANTLR start "rule__MapTypeCS__Group_1__1__Impl"
    // InternalQVTbase.g:11367:1: rule__MapTypeCS__Group_1__1__Impl : ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) ;
    public final void rule__MapTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11371:1: ( ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:11372:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:11372:1: ( ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 ) )
            // InternalQVTbase.g:11373:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1());
            }
            // InternalQVTbase.g:11374:1: ( rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 )
            // InternalQVTbase.g:11374:2: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__OwnedKeyTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__2"
    // InternalQVTbase.g:11384:1: rule__MapTypeCS__Group_1__2 : rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 ;
    public final void rule__MapTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11388:1: ( rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3 )
            // InternalQVTbase.g:11389:2: rule__MapTypeCS__Group_1__2__Impl rule__MapTypeCS__Group_1__3
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__MapTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__2"


    // $ANTLR start "rule__MapTypeCS__Group_1__2__Impl"
    // InternalQVTbase.g:11396:1: rule__MapTypeCS__Group_1__2__Impl : ( ',' ) ;
    public final void rule__MapTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11400:1: ( ( ',' ) )
            // InternalQVTbase.g:11401:1: ( ',' )
            {
            // InternalQVTbase.g:11401:1: ( ',' )
            // InternalQVTbase.g:11402:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getCommaKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__3"
    // InternalQVTbase.g:11415:1: rule__MapTypeCS__Group_1__3 : rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 ;
    public final void rule__MapTypeCS__Group_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11419:1: ( rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4 )
            // InternalQVTbase.g:11420:2: rule__MapTypeCS__Group_1__3__Impl rule__MapTypeCS__Group_1__4
            {
            pushFollow(FollowSets000.FOLLOW_56);
            rule__MapTypeCS__Group_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__3"


    // $ANTLR start "rule__MapTypeCS__Group_1__3__Impl"
    // InternalQVTbase.g:11427:1: rule__MapTypeCS__Group_1__3__Impl : ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) ;
    public final void rule__MapTypeCS__Group_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11431:1: ( ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) ) )
            // InternalQVTbase.g:11432:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            {
            // InternalQVTbase.g:11432:1: ( ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 ) )
            // InternalQVTbase.g:11433:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3());
            }
            // InternalQVTbase.g:11434:1: ( rule__MapTypeCS__OwnedValueTypeAssignment_1_3 )
            // InternalQVTbase.g:11434:2: rule__MapTypeCS__OwnedValueTypeAssignment_1_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__OwnedValueTypeAssignment_1_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeAssignment_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__3__Impl"


    // $ANTLR start "rule__MapTypeCS__Group_1__4"
    // InternalQVTbase.g:11444:1: rule__MapTypeCS__Group_1__4 : rule__MapTypeCS__Group_1__4__Impl ;
    public final void rule__MapTypeCS__Group_1__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11448:1: ( rule__MapTypeCS__Group_1__4__Impl )
            // InternalQVTbase.g:11449:2: rule__MapTypeCS__Group_1__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapTypeCS__Group_1__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__4"


    // $ANTLR start "rule__MapTypeCS__Group_1__4__Impl"
    // InternalQVTbase.g:11455:1: rule__MapTypeCS__Group_1__4__Impl : ( ')' ) ;
    public final void rule__MapTypeCS__Group_1__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11459:1: ( ( ')' ) )
            // InternalQVTbase.g:11460:1: ( ')' )
            {
            // InternalQVTbase.g:11460:1: ( ')' )
            // InternalQVTbase.g:11461:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getRightParenthesisKeyword_1_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__Group_1__4__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group__0"
    // InternalQVTbase.g:11484:1: rule__TupleTypeCS__Group__0 : rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 ;
    public final void rule__TupleTypeCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11488:1: ( rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1 )
            // InternalQVTbase.g:11489:2: rule__TupleTypeCS__Group__0__Impl rule__TupleTypeCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__TupleTypeCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__0"


    // $ANTLR start "rule__TupleTypeCS__Group__0__Impl"
    // InternalQVTbase.g:11496:1: rule__TupleTypeCS__Group__0__Impl : ( ( rule__TupleTypeCS__NameAssignment_0 ) ) ;
    public final void rule__TupleTypeCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11500:1: ( ( ( rule__TupleTypeCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:11501:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:11501:1: ( ( rule__TupleTypeCS__NameAssignment_0 ) )
            // InternalQVTbase.g:11502:1: ( rule__TupleTypeCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:11503:1: ( rule__TupleTypeCS__NameAssignment_0 )
            // InternalQVTbase.g:11503:2: rule__TupleTypeCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group__1"
    // InternalQVTbase.g:11513:1: rule__TupleTypeCS__Group__1 : rule__TupleTypeCS__Group__1__Impl ;
    public final void rule__TupleTypeCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11517:1: ( rule__TupleTypeCS__Group__1__Impl )
            // InternalQVTbase.g:11518:2: rule__TupleTypeCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__1"


    // $ANTLR start "rule__TupleTypeCS__Group__1__Impl"
    // InternalQVTbase.g:11524:1: rule__TupleTypeCS__Group__1__Impl : ( ( rule__TupleTypeCS__Group_1__0 )? ) ;
    public final void rule__TupleTypeCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11528:1: ( ( ( rule__TupleTypeCS__Group_1__0 )? ) )
            // InternalQVTbase.g:11529:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:11529:1: ( ( rule__TupleTypeCS__Group_1__0 )? )
            // InternalQVTbase.g:11530:1: ( rule__TupleTypeCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:11531:1: ( rule__TupleTypeCS__Group_1__0 )?
            int alt133=2;
            int LA133_0 = input.LA(1);

            if ( (LA133_0==71) ) {
                alt133=1;
            }
            switch (alt133) {
                case 1 :
                    // InternalQVTbase.g:11531:2: rule__TupleTypeCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleTypeCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__0"
    // InternalQVTbase.g:11545:1: rule__TupleTypeCS__Group_1__0 : rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 ;
    public final void rule__TupleTypeCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11549:1: ( rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1 )
            // InternalQVTbase.g:11550:2: rule__TupleTypeCS__Group_1__0__Impl rule__TupleTypeCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_32);
            rule__TupleTypeCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1__0__Impl"
    // InternalQVTbase.g:11557:1: rule__TupleTypeCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TupleTypeCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11561:1: ( ( '(' ) )
            // InternalQVTbase.g:11562:1: ( '(' )
            {
            // InternalQVTbase.g:11562:1: ( '(' )
            // InternalQVTbase.g:11563:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__1"
    // InternalQVTbase.g:11576:1: rule__TupleTypeCS__Group_1__1 : rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 ;
    public final void rule__TupleTypeCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11580:1: ( rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2 )
            // InternalQVTbase.g:11581:2: rule__TupleTypeCS__Group_1__1__Impl rule__TupleTypeCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_32);
            rule__TupleTypeCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1__1__Impl"
    // InternalQVTbase.g:11588:1: rule__TupleTypeCS__Group_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1__0 )? ) ;
    public final void rule__TupleTypeCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11592:1: ( ( ( rule__TupleTypeCS__Group_1_1__0 )? ) )
            // InternalQVTbase.g:11593:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            {
            // InternalQVTbase.g:11593:1: ( ( rule__TupleTypeCS__Group_1_1__0 )? )
            // InternalQVTbase.g:11594:1: ( rule__TupleTypeCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1());
            }
            // InternalQVTbase.g:11595:1: ( rule__TupleTypeCS__Group_1_1__0 )?
            int alt134=2;
            int LA134_0 = input.LA(1);

            if ( ((LA134_0>=RULE_SIMPLE_ID && LA134_0<=RULE_ESCAPED_ID)) ) {
                alt134=1;
            }
            switch (alt134) {
                case 1 :
                    // InternalQVTbase.g:11595:2: rule__TupleTypeCS__Group_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleTypeCS__Group_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1__2"
    // InternalQVTbase.g:11605:1: rule__TupleTypeCS__Group_1__2 : rule__TupleTypeCS__Group_1__2__Impl ;
    public final void rule__TupleTypeCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11609:1: ( rule__TupleTypeCS__Group_1__2__Impl )
            // InternalQVTbase.g:11610:2: rule__TupleTypeCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__2"


    // $ANTLR start "rule__TupleTypeCS__Group_1__2__Impl"
    // InternalQVTbase.g:11616:1: rule__TupleTypeCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TupleTypeCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11620:1: ( ( ')' ) )
            // InternalQVTbase.g:11621:1: ( ')' )
            {
            // InternalQVTbase.g:11621:1: ( ')' )
            // InternalQVTbase.g:11622:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getRightParenthesisKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1__2__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__0"
    // InternalQVTbase.g:11641:1: rule__TupleTypeCS__Group_1_1__0 : rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 ;
    public final void rule__TupleTypeCS__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11645:1: ( rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1 )
            // InternalQVTbase.g:11646:2: rule__TupleTypeCS__Group_1_1__0__Impl rule__TupleTypeCS__Group_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__TupleTypeCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__0__Impl"
    // InternalQVTbase.g:11653:1: rule__TupleTypeCS__Group_1_1__0__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) ;
    public final void rule__TupleTypeCS__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11657:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) ) )
            // InternalQVTbase.g:11658:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            {
            // InternalQVTbase.g:11658:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 ) )
            // InternalQVTbase.g:11659:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0());
            }
            // InternalQVTbase.g:11660:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 )
            // InternalQVTbase.g:11660:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__OwnedPartsAssignment_1_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__1"
    // InternalQVTbase.g:11670:1: rule__TupleTypeCS__Group_1_1__1 : rule__TupleTypeCS__Group_1_1__1__Impl ;
    public final void rule__TupleTypeCS__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11674:1: ( rule__TupleTypeCS__Group_1_1__1__Impl )
            // InternalQVTbase.g:11675:2: rule__TupleTypeCS__Group_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1__1__Impl"
    // InternalQVTbase.g:11681:1: rule__TupleTypeCS__Group_1_1__1__Impl : ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) ;
    public final void rule__TupleTypeCS__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11685:1: ( ( ( rule__TupleTypeCS__Group_1_1_1__0 )* ) )
            // InternalQVTbase.g:11686:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            {
            // InternalQVTbase.g:11686:1: ( ( rule__TupleTypeCS__Group_1_1_1__0 )* )
            // InternalQVTbase.g:11687:1: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1());
            }
            // InternalQVTbase.g:11688:1: ( rule__TupleTypeCS__Group_1_1_1__0 )*
            loop135:
            do {
                int alt135=2;
                int LA135_0 = input.LA(1);

                if ( (LA135_0==64) ) {
                    alt135=1;
                }


                switch (alt135) {
            	case 1 :
            	    // InternalQVTbase.g:11688:2: rule__TupleTypeCS__Group_1_1_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__TupleTypeCS__Group_1_1_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop135;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getGroup_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1__1__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0"
    // InternalQVTbase.g:11702:1: rule__TupleTypeCS__Group_1_1_1__0 : rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 ;
    public final void rule__TupleTypeCS__Group_1_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11706:1: ( rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1 )
            // InternalQVTbase.g:11707:2: rule__TupleTypeCS__Group_1_1_1__0__Impl rule__TupleTypeCS__Group_1_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TupleTypeCS__Group_1_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__0__Impl"
    // InternalQVTbase.g:11714:1: rule__TupleTypeCS__Group_1_1_1__0__Impl : ( ',' ) ;
    public final void rule__TupleTypeCS__Group_1_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11718:1: ( ( ',' ) )
            // InternalQVTbase.g:11719:1: ( ',' )
            {
            // InternalQVTbase.g:11719:1: ( ',' )
            // InternalQVTbase.g:11720:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getCommaKeyword_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__0__Impl"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1"
    // InternalQVTbase.g:11733:1: rule__TupleTypeCS__Group_1_1_1__1 : rule__TupleTypeCS__Group_1_1_1__1__Impl ;
    public final void rule__TupleTypeCS__Group_1_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11737:1: ( rule__TupleTypeCS__Group_1_1_1__1__Impl )
            // InternalQVTbase.g:11738:2: rule__TupleTypeCS__Group_1_1_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__Group_1_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__1"


    // $ANTLR start "rule__TupleTypeCS__Group_1_1_1__1__Impl"
    // InternalQVTbase.g:11744:1: rule__TupleTypeCS__Group_1_1_1__1__Impl : ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) ;
    public final void rule__TupleTypeCS__Group_1_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11748:1: ( ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) ) )
            // InternalQVTbase.g:11749:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            {
            // InternalQVTbase.g:11749:1: ( ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 ) )
            // InternalQVTbase.g:11750:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1());
            }
            // InternalQVTbase.g:11751:1: ( rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 )
            // InternalQVTbase.g:11751:2: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsAssignment_1_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__Group_1_1_1__1__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__0"
    // InternalQVTbase.g:11765:1: rule__TuplePartCS__Group__0 : rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 ;
    public final void rule__TuplePartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11769:1: ( rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1 )
            // InternalQVTbase.g:11770:2: rule__TuplePartCS__Group__0__Impl rule__TuplePartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__TuplePartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__0"


    // $ANTLR start "rule__TuplePartCS__Group__0__Impl"
    // InternalQVTbase.g:11777:1: rule__TuplePartCS__Group__0__Impl : ( ( rule__TuplePartCS__NameAssignment_0 ) ) ;
    public final void rule__TuplePartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11781:1: ( ( ( rule__TuplePartCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:11782:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:11782:1: ( ( rule__TuplePartCS__NameAssignment_0 ) )
            // InternalQVTbase.g:11783:1: ( rule__TuplePartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:11784:1: ( rule__TuplePartCS__NameAssignment_0 )
            // InternalQVTbase.g:11784:2: rule__TuplePartCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__0__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__1"
    // InternalQVTbase.g:11794:1: rule__TuplePartCS__Group__1 : rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 ;
    public final void rule__TuplePartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11798:1: ( rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2 )
            // InternalQVTbase.g:11799:2: rule__TuplePartCS__Group__1__Impl rule__TuplePartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__TuplePartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__1"


    // $ANTLR start "rule__TuplePartCS__Group__1__Impl"
    // InternalQVTbase.g:11806:1: rule__TuplePartCS__Group__1__Impl : ( ':' ) ;
    public final void rule__TuplePartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11810:1: ( ( ':' ) )
            // InternalQVTbase.g:11811:1: ( ':' )
            {
            // InternalQVTbase.g:11811:1: ( ':' )
            // InternalQVTbase.g:11812:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getColonKeyword_1());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getColonKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__1__Impl"


    // $ANTLR start "rule__TuplePartCS__Group__2"
    // InternalQVTbase.g:11825:1: rule__TuplePartCS__Group__2 : rule__TuplePartCS__Group__2__Impl ;
    public final void rule__TuplePartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11829:1: ( rule__TuplePartCS__Group__2__Impl )
            // InternalQVTbase.g:11830:2: rule__TuplePartCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__2"


    // $ANTLR start "rule__TuplePartCS__Group__2__Impl"
    // InternalQVTbase.g:11836:1: rule__TuplePartCS__Group__2__Impl : ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) ;
    public final void rule__TuplePartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11840:1: ( ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) ) )
            // InternalQVTbase.g:11841:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            {
            // InternalQVTbase.g:11841:1: ( ( rule__TuplePartCS__OwnedTypeAssignment_2 ) )
            // InternalQVTbase.g:11842:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2());
            }
            // InternalQVTbase.g:11843:1: ( rule__TuplePartCS__OwnedTypeAssignment_2 )
            // InternalQVTbase.g:11843:2: rule__TuplePartCS__OwnedTypeAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TuplePartCS__OwnedTypeAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getOwnedTypeAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__0"
    // InternalQVTbase.g:11859: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 {
            // InternalQVTbase.g:11863:1: ( rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1 )
            // InternalQVTbase.g:11864:2: rule__CollectionLiteralExpCS__Group__0__Impl rule__CollectionLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__CollectionLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:11871:1: rule__CollectionLiteralExpCS__Group__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11875:1: ( ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalQVTbase.g:11876:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalQVTbase.g:11876:1: ( ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalQVTbase.g:11877:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalQVTbase.g:11878:1: ( rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalQVTbase.g:11878:2: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__1"
    // InternalQVTbase.g:11888: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 {
            // InternalQVTbase.g:11892:1: ( rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2 )
            // InternalQVTbase.g:11893:2: rule__CollectionLiteralExpCS__Group__1__Impl rule__CollectionLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_59);
            rule__CollectionLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:11900:1: rule__CollectionLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11904:1: ( ( '{' ) )
            // InternalQVTbase.g:11905:1: ( '{' )
            {
            // InternalQVTbase.g:11905:1: ( '{' )
            // InternalQVTbase.g:11906:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__2"
    // InternalQVTbase.g:11919: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 {
            // InternalQVTbase.g:11923:1: ( rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3 )
            // InternalQVTbase.g:11924:2: rule__CollectionLiteralExpCS__Group__2__Impl rule__CollectionLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_59);
            rule__CollectionLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__2"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__2__Impl"
    // InternalQVTbase.g:11931:1: rule__CollectionLiteralExpCS__Group__2__Impl : ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) ;
    public final void rule__CollectionLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11935:1: ( ( ( rule__CollectionLiteralExpCS__Group_2__0 )? ) )
            // InternalQVTbase.g:11936:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:11936:1: ( ( rule__CollectionLiteralExpCS__Group_2__0 )? )
            // InternalQVTbase.g:11937:1: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:11938:1: ( rule__CollectionLiteralExpCS__Group_2__0 )?
            int alt136=2;
            int LA136_0 = input.LA(1);

            if ( ((LA136_0>=RULE_INT && LA136_0<=RULE_ESCAPED_ID)||(LA136_0>=19 && LA136_0<=22)||(LA136_0>=43 && LA136_0<=57)||LA136_0==61||LA136_0==71||LA136_0==82||(LA136_0>=84 && LA136_0<=85)||LA136_0==90||(LA136_0>=95 && LA136_0<=96)||(LA136_0>=128 && LA136_0<=129)) ) {
                alt136=1;
            }
            switch (alt136) {
                case 1 :
                    // InternalQVTbase.g:11938:2: rule__CollectionLiteralExpCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralExpCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__3"
    // InternalQVTbase.g:11948:1: rule__CollectionLiteralExpCS__Group__3 : rule__CollectionLiteralExpCS__Group__3__Impl ;
    public final void rule__CollectionLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11952:1: ( rule__CollectionLiteralExpCS__Group__3__Impl )
            // InternalQVTbase.g:11953:2: rule__CollectionLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__3"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group__3__Impl"
    // InternalQVTbase.g:11959:1: rule__CollectionLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11963:1: ( ( '}' ) )
            // InternalQVTbase.g:11964:1: ( '}' )
            {
            // InternalQVTbase.g:11964:1: ( '}' )
            // InternalQVTbase.g:11965:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0"
    // InternalQVTbase.g:11986:1: rule__CollectionLiteralExpCS__Group_2__0 : rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 ;
    public final void rule__CollectionLiteralExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:11990:1: ( rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1 )
            // InternalQVTbase.g:11991:2: rule__CollectionLiteralExpCS__Group_2__0__Impl rule__CollectionLiteralExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__CollectionLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__0__Impl"
    // InternalQVTbase.g:11998:1: rule__CollectionLiteralExpCS__Group_2__0__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12002:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalQVTbase.g:12003:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalQVTbase.g:12003:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalQVTbase.g:12004:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalQVTbase.g:12005:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalQVTbase.g:12005:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1"
    // InternalQVTbase.g:12015:1: rule__CollectionLiteralExpCS__Group_2__1 : rule__CollectionLiteralExpCS__Group_2__1__Impl ;
    public final void rule__CollectionLiteralExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12019:1: ( rule__CollectionLiteralExpCS__Group_2__1__Impl )
            // InternalQVTbase.g:12020:2: rule__CollectionLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2__1__Impl"
    // InternalQVTbase.g:12026:1: rule__CollectionLiteralExpCS__Group_2__1__Impl : ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) ;
    public final void rule__CollectionLiteralExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12030:1: ( ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* ) )
            // InternalQVTbase.g:12031:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalQVTbase.g:12031:1: ( ( rule__CollectionLiteralExpCS__Group_2_1__0 )* )
            // InternalQVTbase.g:12032:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:12033:1: ( rule__CollectionLiteralExpCS__Group_2_1__0 )*
            loop137:
            do {
                int alt137=2;
                int LA137_0 = input.LA(1);

                if ( (LA137_0==64) ) {
                    alt137=1;
                }


                switch (alt137) {
            	case 1 :
            	    // InternalQVTbase.g:12033:2: rule__CollectionLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__CollectionLiteralExpCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop137;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0"
    // InternalQVTbase.g:12047:1: rule__CollectionLiteralExpCS__Group_2_1__0 : rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12051:1: ( rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1 )
            // InternalQVTbase.g:12052:2: rule__CollectionLiteralExpCS__Group_2_1__0__Impl rule__CollectionLiteralExpCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_60);
            rule__CollectionLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__0"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:12059:1: rule__CollectionLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12063:1: ( ( ',' ) )
            // InternalQVTbase.g:12064:1: ( ',' )
            {
            // InternalQVTbase.g:12064:1: ( ',' )
            // InternalQVTbase.g:12065:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1"
    // InternalQVTbase.g:12078:1: rule__CollectionLiteralExpCS__Group_2_1__1 : rule__CollectionLiteralExpCS__Group_2_1__1__Impl ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12082:1: ( rule__CollectionLiteralExpCS__Group_2_1__1__Impl )
            // InternalQVTbase.g:12083:2: rule__CollectionLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__1"


    // $ANTLR start "rule__CollectionLiteralExpCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:12089:1: rule__CollectionLiteralExpCS__Group_2_1__1__Impl : ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CollectionLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12093:1: ( ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalQVTbase.g:12094:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalQVTbase.g:12094:1: ( ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalQVTbase.g:12095:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalQVTbase.g:12096:1: ( rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalQVTbase.g:12096:2: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0"
    // InternalQVTbase.g:12110:1: rule__CollectionLiteralPartCS__Group_0__0 : rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 ;
    public final void rule__CollectionLiteralPartCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12114:1: ( rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1 )
            // InternalQVTbase.g:12115:2: rule__CollectionLiteralPartCS__Group_0__0__Impl rule__CollectionLiteralPartCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_61);
            rule__CollectionLiteralPartCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__0__Impl"
    // InternalQVTbase.g:12122:1: rule__CollectionLiteralPartCS__Group_0__0__Impl : ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12126:1: ( ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) ) )
            // InternalQVTbase.g:12127:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            {
            // InternalQVTbase.g:12127:1: ( ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 ) )
            // InternalQVTbase.g:12128:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0());
            }
            // InternalQVTbase.g:12129:1: ( rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 )
            // InternalQVTbase.g:12129:2: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1"
    // InternalQVTbase.g:12139:1: rule__CollectionLiteralPartCS__Group_0__1 : rule__CollectionLiteralPartCS__Group_0__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12143:1: ( rule__CollectionLiteralPartCS__Group_0__1__Impl )
            // InternalQVTbase.g:12144:2: rule__CollectionLiteralPartCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0__1__Impl"
    // InternalQVTbase.g:12150:1: rule__CollectionLiteralPartCS__Group_0__1__Impl : ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) ;
    public final void rule__CollectionLiteralPartCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12154:1: ( ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? ) )
            // InternalQVTbase.g:12155:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            {
            // InternalQVTbase.g:12155:1: ( ( rule__CollectionLiteralPartCS__Group_0_1__0 )? )
            // InternalQVTbase.g:12156:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1());
            }
            // InternalQVTbase.g:12157:1: ( rule__CollectionLiteralPartCS__Group_0_1__0 )?
            int alt138=2;
            int LA138_0 = input.LA(1);

            if ( (LA138_0==80) ) {
                alt138=1;
            }
            switch (alt138) {
                case 1 :
                    // InternalQVTbase.g:12157:2: rule__CollectionLiteralPartCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionLiteralPartCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getGroup_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0__1__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0"
    // InternalQVTbase.g:12171:1: rule__CollectionLiteralPartCS__Group_0_1__0 : rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12175:1: ( rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1 )
            // InternalQVTbase.g:12176:2: rule__CollectionLiteralPartCS__Group_0_1__0__Impl rule__CollectionLiteralPartCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__CollectionLiteralPartCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__0__Impl"
    // InternalQVTbase.g:12183:1: rule__CollectionLiteralPartCS__Group_0_1__0__Impl : ( '..' ) ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12187:1: ( ( '..' ) )
            // InternalQVTbase.g:12188:1: ( '..' )
            {
            // InternalQVTbase.g:12188:1: ( '..' )
            // InternalQVTbase.g:12189:1: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0());
            }
            match(input,80,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getFullStopFullStopKeyword_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1"
    // InternalQVTbase.g:12202:1: rule__CollectionLiteralPartCS__Group_0_1__1 : rule__CollectionLiteralPartCS__Group_0_1__1__Impl ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12206:1: ( rule__CollectionLiteralPartCS__Group_0_1__1__Impl )
            // InternalQVTbase.g:12207:2: rule__CollectionLiteralPartCS__Group_0_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1"


    // $ANTLR start "rule__CollectionLiteralPartCS__Group_0_1__1__Impl"
    // InternalQVTbase.g:12213:1: rule__CollectionLiteralPartCS__Group_0_1__1__Impl : ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) ;
    public final void rule__CollectionLiteralPartCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12217:1: ( ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) ) )
            // InternalQVTbase.g:12218:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            {
            // InternalQVTbase.g:12218:1: ( ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 ) )
            // InternalQVTbase.g:12219:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1());
            }
            // InternalQVTbase.g:12220:1: ( rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 )
            // InternalQVTbase.g:12220:2: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__0"
    // InternalQVTbase.g:12234:1: rule__CollectionPatternCS__Group__0 : rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 ;
    public final void rule__CollectionPatternCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12238:1: ( rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1 )
            // InternalQVTbase.g:12239:2: rule__CollectionPatternCS__Group__0__Impl rule__CollectionPatternCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__CollectionPatternCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__0"


    // $ANTLR start "rule__CollectionPatternCS__Group__0__Impl"
    // InternalQVTbase.g:12246:1: rule__CollectionPatternCS__Group__0__Impl : ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__CollectionPatternCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12250:1: ( ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) ) )
            // InternalQVTbase.g:12251:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            {
            // InternalQVTbase.g:12251:1: ( ( rule__CollectionPatternCS__OwnedTypeAssignment_0 ) )
            // InternalQVTbase.g:12252:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalQVTbase.g:12253:1: ( rule__CollectionPatternCS__OwnedTypeAssignment_0 )
            // InternalQVTbase.g:12253:2: rule__CollectionPatternCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__1"
    // InternalQVTbase.g:12263:1: rule__CollectionPatternCS__Group__1 : rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 ;
    public final void rule__CollectionPatternCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12267:1: ( rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2 )
            // InternalQVTbase.g:12268:2: rule__CollectionPatternCS__Group__1__Impl rule__CollectionPatternCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_59);
            rule__CollectionPatternCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__1"


    // $ANTLR start "rule__CollectionPatternCS__Group__1__Impl"
    // InternalQVTbase.g:12275:1: rule__CollectionPatternCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CollectionPatternCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12279:1: ( ( '{' ) )
            // InternalQVTbase.g:12280:1: ( '{' )
            {
            // InternalQVTbase.g:12280:1: ( '{' )
            // InternalQVTbase.g:12281:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__2"
    // InternalQVTbase.g:12294:1: rule__CollectionPatternCS__Group__2 : rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 ;
    public final void rule__CollectionPatternCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12298:1: ( rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3 )
            // InternalQVTbase.g:12299:2: rule__CollectionPatternCS__Group__2__Impl rule__CollectionPatternCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_59);
            rule__CollectionPatternCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__2"


    // $ANTLR start "rule__CollectionPatternCS__Group__2__Impl"
    // InternalQVTbase.g:12306:1: rule__CollectionPatternCS__Group__2__Impl : ( ( rule__CollectionPatternCS__Group_2__0 )? ) ;
    public final void rule__CollectionPatternCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12310:1: ( ( ( rule__CollectionPatternCS__Group_2__0 )? ) )
            // InternalQVTbase.g:12311:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:12311:1: ( ( rule__CollectionPatternCS__Group_2__0 )? )
            // InternalQVTbase.g:12312:1: ( rule__CollectionPatternCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:12313:1: ( rule__CollectionPatternCS__Group_2__0 )?
            int alt139=2;
            int LA139_0 = input.LA(1);

            if ( ((LA139_0>=RULE_SIMPLE_ID && LA139_0<=RULE_ESCAPED_ID)||LA139_0==61) ) {
                alt139=1;
            }
            switch (alt139) {
                case 1 :
                    // InternalQVTbase.g:12313:2: rule__CollectionPatternCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CollectionPatternCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__2__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group__3"
    // InternalQVTbase.g:12323:1: rule__CollectionPatternCS__Group__3 : rule__CollectionPatternCS__Group__3__Impl ;
    public final void rule__CollectionPatternCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12327:1: ( rule__CollectionPatternCS__Group__3__Impl )
            // InternalQVTbase.g:12328:2: rule__CollectionPatternCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__3"


    // $ANTLR start "rule__CollectionPatternCS__Group__3__Impl"
    // InternalQVTbase.g:12334:1: rule__CollectionPatternCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CollectionPatternCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12338:1: ( ( '}' ) )
            // InternalQVTbase.g:12339:1: ( '}' )
            {
            // InternalQVTbase.g:12339:1: ( '}' )
            // InternalQVTbase.g:12340:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group__3__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__0"
    // InternalQVTbase.g:12361:1: rule__CollectionPatternCS__Group_2__0 : rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 ;
    public final void rule__CollectionPatternCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12365:1: ( rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1 )
            // InternalQVTbase.g:12366:2: rule__CollectionPatternCS__Group_2__0__Impl rule__CollectionPatternCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_63);
            rule__CollectionPatternCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__0__Impl"
    // InternalQVTbase.g:12373:1: rule__CollectionPatternCS__Group_2__0__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CollectionPatternCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12377:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalQVTbase.g:12378:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalQVTbase.g:12378:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 ) )
            // InternalQVTbase.g:12379:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalQVTbase.g:12380:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_0 )
            // InternalQVTbase.g:12380:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__1"
    // InternalQVTbase.g:12390:1: rule__CollectionPatternCS__Group_2__1 : rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 ;
    public final void rule__CollectionPatternCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12394:1: ( rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2 )
            // InternalQVTbase.g:12395:2: rule__CollectionPatternCS__Group_2__1__Impl rule__CollectionPatternCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_63);
            rule__CollectionPatternCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__1__Impl"
    // InternalQVTbase.g:12402:1: rule__CollectionPatternCS__Group_2__1__Impl : ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) ;
    public final void rule__CollectionPatternCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12406:1: ( ( ( rule__CollectionPatternCS__Group_2_1__0 )* ) )
            // InternalQVTbase.g:12407:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            {
            // InternalQVTbase.g:12407:1: ( ( rule__CollectionPatternCS__Group_2_1__0 )* )
            // InternalQVTbase.g:12408:1: ( rule__CollectionPatternCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:12409:1: ( rule__CollectionPatternCS__Group_2_1__0 )*
            loop140:
            do {
                int alt140=2;
                int LA140_0 = input.LA(1);

                if ( (LA140_0==64) ) {
                    alt140=1;
                }


                switch (alt140) {
            	case 1 :
            	    // InternalQVTbase.g:12409:2: rule__CollectionPatternCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__CollectionPatternCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop140;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__2"
    // InternalQVTbase.g:12419:1: rule__CollectionPatternCS__Group_2__2 : rule__CollectionPatternCS__Group_2__2__Impl ;
    public final void rule__CollectionPatternCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12423:1: ( rule__CollectionPatternCS__Group_2__2__Impl )
            // InternalQVTbase.g:12424:2: rule__CollectionPatternCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__2"


    // $ANTLR start "rule__CollectionPatternCS__Group_2__2__Impl"
    // InternalQVTbase.g:12430:1: rule__CollectionPatternCS__Group_2__2__Impl : ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) ;
    public final void rule__CollectionPatternCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12434:1: ( ( ( rule__CollectionPatternCS__Group_2_2__0 ) ) )
            // InternalQVTbase.g:12435:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            {
            // InternalQVTbase.g:12435:1: ( ( rule__CollectionPatternCS__Group_2_2__0 ) )
            // InternalQVTbase.g:12436:1: ( rule__CollectionPatternCS__Group_2_2__0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2());
            }
            // InternalQVTbase.g:12437:1: ( rule__CollectionPatternCS__Group_2_2__0 )
            // InternalQVTbase.g:12437:2: rule__CollectionPatternCS__Group_2_2__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2__2__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0"
    // InternalQVTbase.g:12453:1: rule__CollectionPatternCS__Group_2_1__0 : rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 ;
    public final void rule__CollectionPatternCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12457:1: ( rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1 )
            // InternalQVTbase.g:12458:2: rule__CollectionPatternCS__Group_2_1__0__Impl rule__CollectionPatternCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_60);
            rule__CollectionPatternCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:12465:1: rule__CollectionPatternCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CollectionPatternCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12469:1: ( ( ',' ) )
            // InternalQVTbase.g:12470:1: ( ',' )
            {
            // InternalQVTbase.g:12470:1: ( ',' )
            // InternalQVTbase.g:12471:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1"
    // InternalQVTbase.g:12484:1: rule__CollectionPatternCS__Group_2_1__1 : rule__CollectionPatternCS__Group_2_1__1__Impl ;
    public final void rule__CollectionPatternCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12488:1: ( rule__CollectionPatternCS__Group_2_1__1__Impl )
            // InternalQVTbase.g:12489:2: rule__CollectionPatternCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:12495:1: rule__CollectionPatternCS__Group_2_1__1__Impl : ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CollectionPatternCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12499:1: ( ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalQVTbase.g:12500:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalQVTbase.g:12500:1: ( ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalQVTbase.g:12501:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalQVTbase.g:12502:1: ( rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 )
            // InternalQVTbase.g:12502:2: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0"
    // InternalQVTbase.g:12516:1: rule__CollectionPatternCS__Group_2_2__0 : rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 ;
    public final void rule__CollectionPatternCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12520:1: ( rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1 )
            // InternalQVTbase.g:12521:2: rule__CollectionPatternCS__Group_2_2__0__Impl rule__CollectionPatternCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__CollectionPatternCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__0__Impl"
    // InternalQVTbase.g:12528:1: rule__CollectionPatternCS__Group_2_2__0__Impl : ( '++' ) ;
    public final void rule__CollectionPatternCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12532:1: ( ( '++' ) )
            // InternalQVTbase.g:12533:1: ( '++' )
            {
            // InternalQVTbase.g:12533:1: ( '++' )
            // InternalQVTbase.g:12534:1: '++'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0());
            }
            match(input,81,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getPlusSignPlusSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1"
    // InternalQVTbase.g:12547:1: rule__CollectionPatternCS__Group_2_2__1 : rule__CollectionPatternCS__Group_2_2__1__Impl ;
    public final void rule__CollectionPatternCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12551:1: ( rule__CollectionPatternCS__Group_2_2__1__Impl )
            // InternalQVTbase.g:12552:2: rule__CollectionPatternCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1"


    // $ANTLR start "rule__CollectionPatternCS__Group_2_2__1__Impl"
    // InternalQVTbase.g:12558:1: rule__CollectionPatternCS__Group_2_2__1__Impl : ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) ;
    public final void rule__CollectionPatternCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12562:1: ( ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) ) )
            // InternalQVTbase.g:12563:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            {
            // InternalQVTbase.g:12563:1: ( ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 ) )
            // InternalQVTbase.g:12564:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1());
            }
            // InternalQVTbase.g:12565:1: ( rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 )
            // InternalQVTbase.g:12565:2: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__0"
    // InternalQVTbase.g:12579:1: rule__ShadowPartCS__Group_0__0 : rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 ;
    public final void rule__ShadowPartCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12583:1: ( rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1 )
            // InternalQVTbase.g:12584:2: rule__ShadowPartCS__Group_0__0__Impl rule__ShadowPartCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_64);
            rule__ShadowPartCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__0"


    // $ANTLR start "rule__ShadowPartCS__Group_0__0__Impl"
    // InternalQVTbase.g:12591:1: rule__ShadowPartCS__Group_0__0__Impl : ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) ;
    public final void rule__ShadowPartCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12595:1: ( ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) ) )
            // InternalQVTbase.g:12596:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) )
            {
            // InternalQVTbase.g:12596:1: ( ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 ) )
            // InternalQVTbase.g:12597:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0());
            }
            // InternalQVTbase.g:12598:1: ( rule__ShadowPartCS__ReferredPropertyAssignment_0_0 )
            // InternalQVTbase.g:12598:2: rule__ShadowPartCS__ReferredPropertyAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__ReferredPropertyAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__0__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__1"
    // InternalQVTbase.g:12608:1: rule__ShadowPartCS__Group_0__1 : rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 ;
    public final void rule__ShadowPartCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12612:1: ( rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2 )
            // InternalQVTbase.g:12613:2: rule__ShadowPartCS__Group_0__1__Impl rule__ShadowPartCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_60);
            rule__ShadowPartCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__1"


    // $ANTLR start "rule__ShadowPartCS__Group_0__1__Impl"
    // InternalQVTbase.g:12620:1: rule__ShadowPartCS__Group_0__1__Impl : ( '=' ) ;
    public final void rule__ShadowPartCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12624:1: ( ( '=' ) )
            // InternalQVTbase.g:12625:1: ( '=' )
            {
            // InternalQVTbase.g:12625:1: ( '=' )
            // InternalQVTbase.g:12626:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getEqualsSignKeyword_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__1__Impl"


    // $ANTLR start "rule__ShadowPartCS__Group_0__2"
    // InternalQVTbase.g:12639:1: rule__ShadowPartCS__Group_0__2 : rule__ShadowPartCS__Group_0__2__Impl ;
    public final void rule__ShadowPartCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12643:1: ( rule__ShadowPartCS__Group_0__2__Impl )
            // InternalQVTbase.g:12644:2: rule__ShadowPartCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__2"


    // $ANTLR start "rule__ShadowPartCS__Group_0__2__Impl"
    // InternalQVTbase.g:12650:1: rule__ShadowPartCS__Group_0__2__Impl : ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) ;
    public final void rule__ShadowPartCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12654:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) ) )
            // InternalQVTbase.g:12655:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) )
            {
            // InternalQVTbase.g:12655:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 ) )
            // InternalQVTbase.g:12656:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2());
            }
            // InternalQVTbase.g:12657:1: ( rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 )
            // InternalQVTbase.g:12657:2: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__Group_0__2__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__0"
    // InternalQVTbase.g:12673:1: rule__PatternExpCS__Group__0 : rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 ;
    public final void rule__PatternExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12677:1: ( rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1 )
            // InternalQVTbase.g:12678:2: rule__PatternExpCS__Group__0__Impl rule__PatternExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_60);
            rule__PatternExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__0"


    // $ANTLR start "rule__PatternExpCS__Group__0__Impl"
    // InternalQVTbase.g:12685:1: rule__PatternExpCS__Group__0__Impl : ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) ;
    public final void rule__PatternExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12689:1: ( ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? ) )
            // InternalQVTbase.g:12690:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            {
            // InternalQVTbase.g:12690:1: ( ( rule__PatternExpCS__PatternVariableNameAssignment_0 )? )
            // InternalQVTbase.g:12691:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0());
            }
            // InternalQVTbase.g:12692:1: ( rule__PatternExpCS__PatternVariableNameAssignment_0 )?
            int alt141=2;
            int LA141_0 = input.LA(1);

            if ( ((LA141_0>=RULE_SIMPLE_ID && LA141_0<=RULE_ESCAPED_ID)) ) {
                alt141=1;
            }
            switch (alt141) {
                case 1 :
                    // InternalQVTbase.g:12692:2: rule__PatternExpCS__PatternVariableNameAssignment_0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__PatternExpCS__PatternVariableNameAssignment_0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__0__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__1"
    // InternalQVTbase.g:12702:1: rule__PatternExpCS__Group__1 : rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 ;
    public final void rule__PatternExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12706:1: ( rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2 )
            // InternalQVTbase.g:12707:2: rule__PatternExpCS__Group__1__Impl rule__PatternExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__PatternExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__1"


    // $ANTLR start "rule__PatternExpCS__Group__1__Impl"
    // InternalQVTbase.g:12714:1: rule__PatternExpCS__Group__1__Impl : ( ':' ) ;
    public final void rule__PatternExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12718:1: ( ( ':' ) )
            // InternalQVTbase.g:12719:1: ( ':' )
            {
            // InternalQVTbase.g:12719:1: ( ':' )
            // InternalQVTbase.g:12720:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getColonKeyword_1());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getColonKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__1__Impl"


    // $ANTLR start "rule__PatternExpCS__Group__2"
    // InternalQVTbase.g:12733:1: rule__PatternExpCS__Group__2 : rule__PatternExpCS__Group__2__Impl ;
    public final void rule__PatternExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12737:1: ( rule__PatternExpCS__Group__2__Impl )
            // InternalQVTbase.g:12738:2: rule__PatternExpCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__2"


    // $ANTLR start "rule__PatternExpCS__Group__2__Impl"
    // InternalQVTbase.g:12744:1: rule__PatternExpCS__Group__2__Impl : ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) ;
    public final void rule__PatternExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12748:1: ( ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) ) )
            // InternalQVTbase.g:12749:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            {
            // InternalQVTbase.g:12749:1: ( ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 ) )
            // InternalQVTbase.g:12750:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2());
            }
            // InternalQVTbase.g:12751:1: ( rule__PatternExpCS__OwnedPatternTypeAssignment_2 )
            // InternalQVTbase.g:12751:2: rule__PatternExpCS__OwnedPatternTypeAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PatternExpCS__OwnedPatternTypeAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__Group__2__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__0"
    // InternalQVTbase.g:12767:1: rule__LambdaLiteralExpCS__Group__0 : rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 ;
    public final void rule__LambdaLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12771:1: ( rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1 )
            // InternalQVTbase.g:12772:2: rule__LambdaLiteralExpCS__Group__0__Impl rule__LambdaLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__LambdaLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__0"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:12779:1: rule__LambdaLiteralExpCS__Group__0__Impl : ( 'Lambda' ) ;
    public final void rule__LambdaLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12783:1: ( ( 'Lambda' ) )
            // InternalQVTbase.g:12784:1: ( 'Lambda' )
            {
            // InternalQVTbase.g:12784:1: ( 'Lambda' )
            // InternalQVTbase.g:12785:1: 'Lambda'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0());
            }
            match(input,82,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getLambdaKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__1"
    // InternalQVTbase.g:12798:1: rule__LambdaLiteralExpCS__Group__1 : rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 ;
    public final void rule__LambdaLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12802:1: ( rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2 )
            // InternalQVTbase.g:12803:2: rule__LambdaLiteralExpCS__Group__1__Impl rule__LambdaLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__LambdaLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__1"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:12810:1: rule__LambdaLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__LambdaLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12814:1: ( ( '{' ) )
            // InternalQVTbase.g:12815:1: ( '{' )
            {
            // InternalQVTbase.g:12815:1: ( '{' )
            // InternalQVTbase.g:12816:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__2"
    // InternalQVTbase.g:12829:1: rule__LambdaLiteralExpCS__Group__2 : rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 ;
    public final void rule__LambdaLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12833:1: ( rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3 )
            // InternalQVTbase.g:12834:2: rule__LambdaLiteralExpCS__Group__2__Impl rule__LambdaLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__LambdaLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__2"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__2__Impl"
    // InternalQVTbase.g:12841:1: rule__LambdaLiteralExpCS__Group__2__Impl : ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) ;
    public final void rule__LambdaLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12845:1: ( ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) ) )
            // InternalQVTbase.g:12846:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            {
            // InternalQVTbase.g:12846:1: ( ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 ) )
            // InternalQVTbase.g:12847:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2());
            }
            // InternalQVTbase.g:12848:1: ( rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 )
            // InternalQVTbase.g:12848:2: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__3"
    // InternalQVTbase.g:12858:1: rule__LambdaLiteralExpCS__Group__3 : rule__LambdaLiteralExpCS__Group__3__Impl ;
    public final void rule__LambdaLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12862:1: ( rule__LambdaLiteralExpCS__Group__3__Impl )
            // InternalQVTbase.g:12863:2: rule__LambdaLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LambdaLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__3"


    // $ANTLR start "rule__LambdaLiteralExpCS__Group__3__Impl"
    // InternalQVTbase.g:12869:1: rule__LambdaLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__LambdaLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12873:1: ( ( '}' ) )
            // InternalQVTbase.g:12874:1: ( '}' )
            {
            // InternalQVTbase.g:12874:1: ( '}' )
            // InternalQVTbase.g:12875:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__0"
    // InternalQVTbase.g:12896:1: rule__MapLiteralExpCS__Group__0 : rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 ;
    public final void rule__MapLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12900:1: ( rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1 )
            // InternalQVTbase.g:12901:2: rule__MapLiteralExpCS__Group__0__Impl rule__MapLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__MapLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:12908:1: rule__MapLiteralExpCS__Group__0__Impl : ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) ;
    public final void rule__MapLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12912:1: ( ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) ) )
            // InternalQVTbase.g:12913:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            {
            // InternalQVTbase.g:12913:1: ( ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 ) )
            // InternalQVTbase.g:12914:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }
            // InternalQVTbase.g:12915:1: ( rule__MapLiteralExpCS__OwnedTypeAssignment_0 )
            // InternalQVTbase.g:12915:2: rule__MapLiteralExpCS__OwnedTypeAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedTypeAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__1"
    // InternalQVTbase.g:12925:1: rule__MapLiteralExpCS__Group__1 : rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 ;
    public final void rule__MapLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12929:1: ( rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2 )
            // InternalQVTbase.g:12930:2: rule__MapLiteralExpCS__Group__1__Impl rule__MapLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_65);
            rule__MapLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:12937:1: rule__MapLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__MapLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12941:1: ( ( '{' ) )
            // InternalQVTbase.g:12942:1: ( '{' )
            {
            // InternalQVTbase.g:12942:1: ( '{' )
            // InternalQVTbase.g:12943:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__2"
    // InternalQVTbase.g:12956:1: rule__MapLiteralExpCS__Group__2 : rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 ;
    public final void rule__MapLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12960:1: ( rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3 )
            // InternalQVTbase.g:12961:2: rule__MapLiteralExpCS__Group__2__Impl rule__MapLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_65);
            rule__MapLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__2"


    // $ANTLR start "rule__MapLiteralExpCS__Group__2__Impl"
    // InternalQVTbase.g:12968:1: rule__MapLiteralExpCS__Group__2__Impl : ( ( rule__MapLiteralExpCS__Group_2__0 )? ) ;
    public final void rule__MapLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12972:1: ( ( ( rule__MapLiteralExpCS__Group_2__0 )? ) )
            // InternalQVTbase.g:12973:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:12973:1: ( ( rule__MapLiteralExpCS__Group_2__0 )? )
            // InternalQVTbase.g:12974:1: ( rule__MapLiteralExpCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:12975:1: ( rule__MapLiteralExpCS__Group_2__0 )?
            int alt142=2;
            int LA142_0 = input.LA(1);

            if ( ((LA142_0>=RULE_INT && LA142_0<=RULE_ESCAPED_ID)||(LA142_0>=19 && LA142_0<=22)||(LA142_0>=43 && LA142_0<=57)||LA142_0==71||LA142_0==82||(LA142_0>=84 && LA142_0<=85)||LA142_0==90||(LA142_0>=95 && LA142_0<=96)||(LA142_0>=128 && LA142_0<=129)) ) {
                alt142=1;
            }
            switch (alt142) {
                case 1 :
                    // InternalQVTbase.g:12975:2: rule__MapLiteralExpCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MapLiteralExpCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group__3"
    // InternalQVTbase.g:12985:1: rule__MapLiteralExpCS__Group__3 : rule__MapLiteralExpCS__Group__3__Impl ;
    public final void rule__MapLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:12989:1: ( rule__MapLiteralExpCS__Group__3__Impl )
            // InternalQVTbase.g:12990:2: rule__MapLiteralExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__3"


    // $ANTLR start "rule__MapLiteralExpCS__Group__3__Impl"
    // InternalQVTbase.g:12996:1: rule__MapLiteralExpCS__Group__3__Impl : ( '}' ) ;
    public final void rule__MapLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13000:1: ( ( '}' ) )
            // InternalQVTbase.g:13001:1: ( '}' )
            {
            // InternalQVTbase.g:13001:1: ( '}' )
            // InternalQVTbase.g:13002:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__0"
    // InternalQVTbase.g:13023:1: rule__MapLiteralExpCS__Group_2__0 : rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 ;
    public final void rule__MapLiteralExpCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13027:1: ( rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1 )
            // InternalQVTbase.g:13028:2: rule__MapLiteralExpCS__Group_2__0__Impl rule__MapLiteralExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__MapLiteralExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__0__Impl"
    // InternalQVTbase.g:13035:1: rule__MapLiteralExpCS__Group_2__0__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__MapLiteralExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13039:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalQVTbase.g:13040:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalQVTbase.g:13040:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 ) )
            // InternalQVTbase.g:13041:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalQVTbase.g:13042:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 )
            // InternalQVTbase.g:13042:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__1"
    // InternalQVTbase.g:13052:1: rule__MapLiteralExpCS__Group_2__1 : rule__MapLiteralExpCS__Group_2__1__Impl ;
    public final void rule__MapLiteralExpCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13056:1: ( rule__MapLiteralExpCS__Group_2__1__Impl )
            // InternalQVTbase.g:13057:2: rule__MapLiteralExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2__1__Impl"
    // InternalQVTbase.g:13063:1: rule__MapLiteralExpCS__Group_2__1__Impl : ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) ;
    public final void rule__MapLiteralExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13067:1: ( ( ( rule__MapLiteralExpCS__Group_2_1__0 )* ) )
            // InternalQVTbase.g:13068:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            {
            // InternalQVTbase.g:13068:1: ( ( rule__MapLiteralExpCS__Group_2_1__0 )* )
            // InternalQVTbase.g:13069:1: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:13070:1: ( rule__MapLiteralExpCS__Group_2_1__0 )*
            loop143:
            do {
                int alt143=2;
                int LA143_0 = input.LA(1);

                if ( (LA143_0==64) ) {
                    alt143=1;
                }


                switch (alt143) {
            	case 1 :
            	    // InternalQVTbase.g:13070:2: rule__MapLiteralExpCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__MapLiteralExpCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop143;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0"
    // InternalQVTbase.g:13084:1: rule__MapLiteralExpCS__Group_2_1__0 : rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 ;
    public final void rule__MapLiteralExpCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13088:1: ( rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1 )
            // InternalQVTbase.g:13089:2: rule__MapLiteralExpCS__Group_2_1__0__Impl rule__MapLiteralExpCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__MapLiteralExpCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__0"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:13096:1: rule__MapLiteralExpCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__MapLiteralExpCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13100:1: ( ( ',' ) )
            // InternalQVTbase.g:13101:1: ( ',' )
            {
            // InternalQVTbase.g:13101:1: ( ',' )
            // InternalQVTbase.g:13102:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1"
    // InternalQVTbase.g:13115:1: rule__MapLiteralExpCS__Group_2_1__1 : rule__MapLiteralExpCS__Group_2_1__1__Impl ;
    public final void rule__MapLiteralExpCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13119:1: ( rule__MapLiteralExpCS__Group_2_1__1__Impl )
            // InternalQVTbase.g:13120:2: rule__MapLiteralExpCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__1"


    // $ANTLR start "rule__MapLiteralExpCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:13126:1: rule__MapLiteralExpCS__Group_2_1__1__Impl : ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__MapLiteralExpCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13130:1: ( ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalQVTbase.g:13131:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalQVTbase.g:13131:1: ( ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalQVTbase.g:13132:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalQVTbase.g:13133:1: ( rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 )
            // InternalQVTbase.g:13133:2: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__0"
    // InternalQVTbase.g:13147:1: rule__MapLiteralPartCS__Group__0 : rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 ;
    public final void rule__MapLiteralPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13151:1: ( rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1 )
            // InternalQVTbase.g:13152:2: rule__MapLiteralPartCS__Group__0__Impl rule__MapLiteralPartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_66);
            rule__MapLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__0"


    // $ANTLR start "rule__MapLiteralPartCS__Group__0__Impl"
    // InternalQVTbase.g:13159:1: rule__MapLiteralPartCS__Group__0__Impl : ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) ;
    public final void rule__MapLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13163:1: ( ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) ) )
            // InternalQVTbase.g:13164:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            {
            // InternalQVTbase.g:13164:1: ( ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 ) )
            // InternalQVTbase.g:13165:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0());
            }
            // InternalQVTbase.g:13166:1: ( rule__MapLiteralPartCS__OwnedKeyAssignment_0 )
            // InternalQVTbase.g:13166:2: rule__MapLiteralPartCS__OwnedKeyAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__OwnedKeyAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__0__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__1"
    // InternalQVTbase.g:13176:1: rule__MapLiteralPartCS__Group__1 : rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 ;
    public final void rule__MapLiteralPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13180:1: ( rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2 )
            // InternalQVTbase.g:13181:2: rule__MapLiteralPartCS__Group__1__Impl rule__MapLiteralPartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__MapLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__1"


    // $ANTLR start "rule__MapLiteralPartCS__Group__1__Impl"
    // InternalQVTbase.g:13188:1: rule__MapLiteralPartCS__Group__1__Impl : ( '<-' ) ;
    public final void rule__MapLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13192:1: ( ( '<-' ) )
            // InternalQVTbase.g:13193:1: ( '<-' )
            {
            // InternalQVTbase.g:13193:1: ( '<-' )
            // InternalQVTbase.g:13194:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getLessThanSignHyphenMinusKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__1__Impl"


    // $ANTLR start "rule__MapLiteralPartCS__Group__2"
    // InternalQVTbase.g:13207:1: rule__MapLiteralPartCS__Group__2 : rule__MapLiteralPartCS__Group__2__Impl ;
    public final void rule__MapLiteralPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13211:1: ( rule__MapLiteralPartCS__Group__2__Impl )
            // InternalQVTbase.g:13212:2: rule__MapLiteralPartCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__2"


    // $ANTLR start "rule__MapLiteralPartCS__Group__2__Impl"
    // InternalQVTbase.g:13218:1: rule__MapLiteralPartCS__Group__2__Impl : ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) ;
    public final void rule__MapLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13222:1: ( ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) ) )
            // InternalQVTbase.g:13223:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            {
            // InternalQVTbase.g:13223:1: ( ( rule__MapLiteralPartCS__OwnedValueAssignment_2 ) )
            // InternalQVTbase.g:13224:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2());
            }
            // InternalQVTbase.g:13225:1: ( rule__MapLiteralPartCS__OwnedValueAssignment_2 )
            // InternalQVTbase.g:13225:2: rule__MapLiteralPartCS__OwnedValueAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MapLiteralPartCS__OwnedValueAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__0"
    // InternalQVTbase.g:13241:1: rule__TupleLiteralExpCS__Group__0 : rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 ;
    public final void rule__TupleLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13245:1: ( rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1 )
            // InternalQVTbase.g:13246:2: rule__TupleLiteralExpCS__Group__0__Impl rule__TupleLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__TupleLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__0"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:13253:1: rule__TupleLiteralExpCS__Group__0__Impl : ( 'Tuple' ) ;
    public final void rule__TupleLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13257:1: ( ( 'Tuple' ) )
            // InternalQVTbase.g:13258:1: ( 'Tuple' )
            {
            // InternalQVTbase.g:13258:1: ( 'Tuple' )
            // InternalQVTbase.g:13259:1: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0());
            }
            match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getTupleKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__1"
    // InternalQVTbase.g:13272:1: rule__TupleLiteralExpCS__Group__1 : rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 ;
    public final void rule__TupleLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13276:1: ( rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2 )
            // InternalQVTbase.g:13277:2: rule__TupleLiteralExpCS__Group__1__Impl rule__TupleLiteralExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TupleLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__1"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:13284:1: rule__TupleLiteralExpCS__Group__1__Impl : ( '{' ) ;
    public final void rule__TupleLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13288:1: ( ( '{' ) )
            // InternalQVTbase.g:13289:1: ( '{' )
            {
            // InternalQVTbase.g:13289:1: ( '{' )
            // InternalQVTbase.g:13290:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__2"
    // InternalQVTbase.g:13303:1: rule__TupleLiteralExpCS__Group__2 : rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 ;
    public final void rule__TupleLiteralExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13307:1: ( rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3 )
            // InternalQVTbase.g:13308:2: rule__TupleLiteralExpCS__Group__2__Impl rule__TupleLiteralExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_67);
            rule__TupleLiteralExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__2"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__2__Impl"
    // InternalQVTbase.g:13315:1: rule__TupleLiteralExpCS__Group__2__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) ;
    public final void rule__TupleLiteralExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13319:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) ) )
            // InternalQVTbase.g:13320:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            {
            // InternalQVTbase.g:13320:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 ) )
            // InternalQVTbase.g:13321:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2());
            }
            // InternalQVTbase.g:13322:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_2 )
            // InternalQVTbase.g:13322:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__OwnedPartsAssignment_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__3"
    // InternalQVTbase.g:13332:1: rule__TupleLiteralExpCS__Group__3 : rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 ;
    public final void rule__TupleLiteralExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13336:1: ( rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4 )
            // InternalQVTbase.g:13337:2: rule__TupleLiteralExpCS__Group__3__Impl rule__TupleLiteralExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_67);
            rule__TupleLiteralExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__3"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__3__Impl"
    // InternalQVTbase.g:13344:1: rule__TupleLiteralExpCS__Group__3__Impl : ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) ;
    public final void rule__TupleLiteralExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13348:1: ( ( ( rule__TupleLiteralExpCS__Group_3__0 )* ) )
            // InternalQVTbase.g:13349:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            {
            // InternalQVTbase.g:13349:1: ( ( rule__TupleLiteralExpCS__Group_3__0 )* )
            // InternalQVTbase.g:13350:1: ( rule__TupleLiteralExpCS__Group_3__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3());
            }
            // InternalQVTbase.g:13351:1: ( rule__TupleLiteralExpCS__Group_3__0 )*
            loop144:
            do {
                int alt144=2;
                int LA144_0 = input.LA(1);

                if ( (LA144_0==64) ) {
                    alt144=1;
                }


                switch (alt144) {
            	case 1 :
            	    // InternalQVTbase.g:13351:2: rule__TupleLiteralExpCS__Group_3__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__TupleLiteralExpCS__Group_3__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop144;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getGroup_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__3__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__4"
    // InternalQVTbase.g:13361:1: rule__TupleLiteralExpCS__Group__4 : rule__TupleLiteralExpCS__Group__4__Impl ;
    public final void rule__TupleLiteralExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13365:1: ( rule__TupleLiteralExpCS__Group__4__Impl )
            // InternalQVTbase.g:13366:2: rule__TupleLiteralExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__4"


    // $ANTLR start "rule__TupleLiteralExpCS__Group__4__Impl"
    // InternalQVTbase.g:13372:1: rule__TupleLiteralExpCS__Group__4__Impl : ( '}' ) ;
    public final void rule__TupleLiteralExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13376:1: ( ( '}' ) )
            // InternalQVTbase.g:13377:1: ( '}' )
            {
            // InternalQVTbase.g:13377:1: ( '}' )
            // InternalQVTbase.g:13378:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getRightCurlyBracketKeyword_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group__4__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0"
    // InternalQVTbase.g:13401:1: rule__TupleLiteralExpCS__Group_3__0 : rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 ;
    public final void rule__TupleLiteralExpCS__Group_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13405:1: ( rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1 )
            // InternalQVTbase.g:13406:2: rule__TupleLiteralExpCS__Group_3__0__Impl rule__TupleLiteralExpCS__Group_3__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TupleLiteralExpCS__Group_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__0__Impl"
    // InternalQVTbase.g:13413:1: rule__TupleLiteralExpCS__Group_3__0__Impl : ( ',' ) ;
    public final void rule__TupleLiteralExpCS__Group_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13417:1: ( ( ',' ) )
            // InternalQVTbase.g:13418:1: ( ',' )
            {
            // InternalQVTbase.g:13418:1: ( ',' )
            // InternalQVTbase.g:13419:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getCommaKeyword_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__0__Impl"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1"
    // InternalQVTbase.g:13432:1: rule__TupleLiteralExpCS__Group_3__1 : rule__TupleLiteralExpCS__Group_3__1__Impl ;
    public final void rule__TupleLiteralExpCS__Group_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13436:1: ( rule__TupleLiteralExpCS__Group_3__1__Impl )
            // InternalQVTbase.g:13437:2: rule__TupleLiteralExpCS__Group_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__Group_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1"


    // $ANTLR start "rule__TupleLiteralExpCS__Group_3__1__Impl"
    // InternalQVTbase.g:13443:1: rule__TupleLiteralExpCS__Group_3__1__Impl : ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) ;
    public final void rule__TupleLiteralExpCS__Group_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13447:1: ( ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) ) )
            // InternalQVTbase.g:13448:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            {
            // InternalQVTbase.g:13448:1: ( ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 ) )
            // InternalQVTbase.g:13449:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1());
            }
            // InternalQVTbase.g:13450:1: ( rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 )
            // InternalQVTbase.g:13450:2: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsAssignment_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__Group_3__1__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__0"
    // InternalQVTbase.g:13464:1: rule__TupleLiteralPartCS__Group__0 : rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 ;
    public final void rule__TupleLiteralPartCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13468:1: ( rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1 )
            // InternalQVTbase.g:13469:2: rule__TupleLiteralPartCS__Group__0__Impl rule__TupleLiteralPartCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_68);
            rule__TupleLiteralPartCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__0"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__0__Impl"
    // InternalQVTbase.g:13476:1: rule__TupleLiteralPartCS__Group__0__Impl : ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13480:1: ( ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:13481:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:13481:1: ( ( rule__TupleLiteralPartCS__NameAssignment_0 ) )
            // InternalQVTbase.g:13482:1: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:13483:1: ( rule__TupleLiteralPartCS__NameAssignment_0 )
            // InternalQVTbase.g:13483:2: rule__TupleLiteralPartCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__0__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__1"
    // InternalQVTbase.g:13493:1: rule__TupleLiteralPartCS__Group__1 : rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 ;
    public final void rule__TupleLiteralPartCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13497:1: ( rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2 )
            // InternalQVTbase.g:13498:2: rule__TupleLiteralPartCS__Group__1__Impl rule__TupleLiteralPartCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_68);
            rule__TupleLiteralPartCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__1"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__1__Impl"
    // InternalQVTbase.g:13505:1: rule__TupleLiteralPartCS__Group__1__Impl : ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) ;
    public final void rule__TupleLiteralPartCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13509:1: ( ( ( rule__TupleLiteralPartCS__Group_1__0 )? ) )
            // InternalQVTbase.g:13510:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:13510:1: ( ( rule__TupleLiteralPartCS__Group_1__0 )? )
            // InternalQVTbase.g:13511:1: ( rule__TupleLiteralPartCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:13512:1: ( rule__TupleLiteralPartCS__Group_1__0 )?
            int alt145=2;
            int LA145_0 = input.LA(1);

            if ( (LA145_0==61) ) {
                alt145=1;
            }
            switch (alt145) {
                case 1 :
                    // InternalQVTbase.g:13512:2: rule__TupleLiteralPartCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TupleLiteralPartCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__1__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__2"
    // InternalQVTbase.g:13522:1: rule__TupleLiteralPartCS__Group__2 : rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 ;
    public final void rule__TupleLiteralPartCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13526:1: ( rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3 )
            // InternalQVTbase.g:13527:2: rule__TupleLiteralPartCS__Group__2__Impl rule__TupleLiteralPartCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__TupleLiteralPartCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__2"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__2__Impl"
    // InternalQVTbase.g:13534:1: rule__TupleLiteralPartCS__Group__2__Impl : ( '=' ) ;
    public final void rule__TupleLiteralPartCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13538:1: ( ( '=' ) )
            // InternalQVTbase.g:13539:1: ( '=' )
            {
            // InternalQVTbase.g:13539:1: ( '=' )
            // InternalQVTbase.g:13540:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getEqualsSignKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__2__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__3"
    // InternalQVTbase.g:13553:1: rule__TupleLiteralPartCS__Group__3 : rule__TupleLiteralPartCS__Group__3__Impl ;
    public final void rule__TupleLiteralPartCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13557:1: ( rule__TupleLiteralPartCS__Group__3__Impl )
            // InternalQVTbase.g:13558:2: rule__TupleLiteralPartCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__3"


    // $ANTLR start "rule__TupleLiteralPartCS__Group__3__Impl"
    // InternalQVTbase.g:13564:1: rule__TupleLiteralPartCS__Group__3__Impl : ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) ;
    public final void rule__TupleLiteralPartCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13568:1: ( ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) ) )
            // InternalQVTbase.g:13569:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            {
            // InternalQVTbase.g:13569:1: ( ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 ) )
            // InternalQVTbase.g:13570:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3());
            }
            // InternalQVTbase.g:13571:1: ( rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 )
            // InternalQVTbase.g:13571:2: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group__3__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0"
    // InternalQVTbase.g:13589:1: rule__TupleLiteralPartCS__Group_1__0 : rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 ;
    public final void rule__TupleLiteralPartCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13593:1: ( rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1 )
            // InternalQVTbase.g:13594:2: rule__TupleLiteralPartCS__Group_1__0__Impl rule__TupleLiteralPartCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__TupleLiteralPartCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__0__Impl"
    // InternalQVTbase.g:13601:1: rule__TupleLiteralPartCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__TupleLiteralPartCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13605:1: ( ( ':' ) )
            // InternalQVTbase.g:13606:1: ( ':' )
            {
            // InternalQVTbase.g:13606:1: ( ':' )
            // InternalQVTbase.g:13607:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__0__Impl"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1"
    // InternalQVTbase.g:13620:1: rule__TupleLiteralPartCS__Group_1__1 : rule__TupleLiteralPartCS__Group_1__1__Impl ;
    public final void rule__TupleLiteralPartCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13624:1: ( rule__TupleLiteralPartCS__Group_1__1__Impl )
            // InternalQVTbase.g:13625:2: rule__TupleLiteralPartCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__1"


    // $ANTLR start "rule__TupleLiteralPartCS__Group_1__1__Impl"
    // InternalQVTbase.g:13631:1: rule__TupleLiteralPartCS__Group_1__1__Impl : ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__TupleLiteralPartCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13635:1: ( ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:13636:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:13636:1: ( ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 ) )
            // InternalQVTbase.g:13637:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalQVTbase.g:13638:1: ( rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 )
            // InternalQVTbase.g:13638:2: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__Group_1__1__Impl"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0"
    // InternalQVTbase.g:13652:1: rule__UnlimitedNaturalLiteralExpCS__Group__0 : rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13656:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1 )
            // InternalQVTbase.g:13657:2: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl rule__UnlimitedNaturalLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_69);
            rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:13664:1: rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13668:1: ( ( () ) )
            // InternalQVTbase.g:13669:1: ( () )
            {
            // InternalQVTbase.g:13669:1: ( () )
            // InternalQVTbase.g:13670:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0());
            }
            // InternalQVTbase.g:13671:1: ()
            // InternalQVTbase.g:13673:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getUnlimitedNaturalLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1"
    // InternalQVTbase.g:13683:1: rule__UnlimitedNaturalLiteralExpCS__Group__1 : rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13687:1: ( rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl )
            // InternalQVTbase.g:13688:2: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1"


    // $ANTLR start "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:13694:1: rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl : ( '*' ) ;
    public final void rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13698:1: ( ( '*' ) )
            // InternalQVTbase.g:13699:1: ( '*' )
            {
            // InternalQVTbase.g:13699:1: ( '*' )
            // InternalQVTbase.g:13700:1: '*'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1());
            }
            match(input,22,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getUnlimitedNaturalLiteralExpCSAccess().getAsteriskKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__UnlimitedNaturalLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__0"
    // InternalQVTbase.g:13717:1: rule__InvalidLiteralExpCS__Group__0 : rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 ;
    public final void rule__InvalidLiteralExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13721:1: ( rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1 )
            // InternalQVTbase.g:13722:2: rule__InvalidLiteralExpCS__Group__0__Impl rule__InvalidLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_70);
            rule__InvalidLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__0"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:13729:1: rule__InvalidLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__InvalidLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13733:1: ( ( () ) )
            // InternalQVTbase.g:13734:1: ( () )
            {
            // InternalQVTbase.g:13734:1: ( () )
            // InternalQVTbase.g:13735:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0());
            }
            // InternalQVTbase.g:13736:1: ()
            // InternalQVTbase.g:13738:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__1"
    // InternalQVTbase.g:13748:1: rule__InvalidLiteralExpCS__Group__1 : rule__InvalidLiteralExpCS__Group__1__Impl ;
    public final void rule__InvalidLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13752:1: ( rule__InvalidLiteralExpCS__Group__1__Impl )
            // InternalQVTbase.g:13753:2: rule__InvalidLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__InvalidLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__1"


    // $ANTLR start "rule__InvalidLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:13759:1: rule__InvalidLiteralExpCS__Group__1__Impl : ( 'invalid' ) ;
    public final void rule__InvalidLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13763:1: ( ( 'invalid' ) )
            // InternalQVTbase.g:13764:1: ( 'invalid' )
            {
            // InternalQVTbase.g:13764:1: ( 'invalid' )
            // InternalQVTbase.g:13765:1: 'invalid'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1());
            }
            match(input,84,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getInvalidLiteralExpCSAccess().getInvalidKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__InvalidLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__NullLiteralExpCS__Group__0"
    // InternalQVTbase.g:13782: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 {
            // InternalQVTbase.g:13786:1: ( rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1 )
            // InternalQVTbase.g:13787:2: rule__NullLiteralExpCS__Group__0__Impl rule__NullLiteralExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_71);
            rule__NullLiteralExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__0"


    // $ANTLR start "rule__NullLiteralExpCS__Group__0__Impl"
    // InternalQVTbase.g:13794:1: rule__NullLiteralExpCS__Group__0__Impl : ( () ) ;
    public final void rule__NullLiteralExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13798:1: ( ( () ) )
            // InternalQVTbase.g:13799:1: ( () )
            {
            // InternalQVTbase.g:13799:1: ( () )
            // InternalQVTbase.g:13800:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0());
            }
            // InternalQVTbase.g:13801:1: ()
            // InternalQVTbase.g:13803:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSAccess().getNullLiteralExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__0__Impl"


    // $ANTLR start "rule__NullLiteralExpCS__Group__1"
    // InternalQVTbase.g:13813:1: rule__NullLiteralExpCS__Group__1 : rule__NullLiteralExpCS__Group__1__Impl ;
    public final void rule__NullLiteralExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13817:1: ( rule__NullLiteralExpCS__Group__1__Impl )
            // InternalQVTbase.g:13818:2: rule__NullLiteralExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NullLiteralExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__1"


    // $ANTLR start "rule__NullLiteralExpCS__Group__1__Impl"
    // InternalQVTbase.g:13824:1: rule__NullLiteralExpCS__Group__1__Impl : ( 'null' ) ;
    public final void rule__NullLiteralExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13828:1: ( ( 'null' ) )
            // InternalQVTbase.g:13829:1: ( 'null' )
            {
            // InternalQVTbase.g:13829:1: ( 'null' )
            // InternalQVTbase.g:13830:1: 'null'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1());
            }
            match(input,85,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNullLiteralExpCSAccess().getNullKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NullLiteralExpCS__Group__1__Impl"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0"
    // InternalQVTbase.g:13847:1: rule__TypeLiteralWithMultiplicityCS__Group__0 : rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13851:1: ( rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1 )
            // InternalQVTbase.g:13852:2: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl rule__TypeLiteralWithMultiplicityCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_54);
            rule__TypeLiteralWithMultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl"
    // InternalQVTbase.g:13859:1: rule__TypeLiteralWithMultiplicityCS__Group__0__Impl : ( ruleTypeLiteralCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13863:1: ( ( ruleTypeLiteralCS ) )
            // InternalQVTbase.g:13864:1: ( ruleTypeLiteralCS )
            {
            // InternalQVTbase.g:13864:1: ( ruleTypeLiteralCS )
            // InternalQVTbase.g:13865:1: ruleTypeLiteralCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeLiteralCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__0__Impl"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1"
    // InternalQVTbase.g:13876:1: rule__TypeLiteralWithMultiplicityCS__Group__1 : rule__TypeLiteralWithMultiplicityCS__Group__1__Impl ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13880:1: ( rule__TypeLiteralWithMultiplicityCS__Group__1__Impl )
            // InternalQVTbase.g:13881:2: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeLiteralWithMultiplicityCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl"
    // InternalQVTbase.g:13887:1: rule__TypeLiteralWithMultiplicityCS__Group__1__Impl : ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13891:1: ( ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalQVTbase.g:13892:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalQVTbase.g:13892:1: ( ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )? )
            // InternalQVTbase.g:13893:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1());
            }
            // InternalQVTbase.g:13894:1: ( rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 )?
            int alt146=2;
            int LA146_0 = input.LA(1);

            if ( (LA146_0==87) ) {
                alt146=1;
            }
            switch (alt146) {
                case 1 :
                    // InternalQVTbase.g:13894:2: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__Group__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group__0"
    // InternalQVTbase.g:13908:1: rule__TypeNameExpCS__Group__0 : rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 ;
    public final void rule__TypeNameExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13912:1: ( rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1 )
            // InternalQVTbase.g:13913:2: rule__TypeNameExpCS__Group__0__Impl rule__TypeNameExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__TypeNameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__0"


    // $ANTLR start "rule__TypeNameExpCS__Group__0__Impl"
    // InternalQVTbase.g:13920:1: rule__TypeNameExpCS__Group__0__Impl : ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypeNameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13924:1: ( ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalQVTbase.g:13925:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalQVTbase.g:13925:1: ( ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalQVTbase.g:13926:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalQVTbase.g:13927:1: ( rule__TypeNameExpCS__OwnedPathNameAssignment_0 )
            // InternalQVTbase.g:13927:2: rule__TypeNameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group__1"
    // InternalQVTbase.g:13937:1: rule__TypeNameExpCS__Group__1 : rule__TypeNameExpCS__Group__1__Impl ;
    public final void rule__TypeNameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13941:1: ( rule__TypeNameExpCS__Group__1__Impl )
            // InternalQVTbase.g:13942:2: rule__TypeNameExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__1"


    // $ANTLR start "rule__TypeNameExpCS__Group__1__Impl"
    // InternalQVTbase.g:13948:1: rule__TypeNameExpCS__Group__1__Impl : ( ( rule__TypeNameExpCS__Group_1__0 )? ) ;
    public final void rule__TypeNameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13952:1: ( ( ( rule__TypeNameExpCS__Group_1__0 )? ) )
            // InternalQVTbase.g:13953:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:13953:1: ( ( rule__TypeNameExpCS__Group_1__0 )? )
            // InternalQVTbase.g:13954:1: ( rule__TypeNameExpCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:13955:1: ( rule__TypeNameExpCS__Group_1__0 )?
            int alt147=2;
            int LA147_0 = input.LA(1);

            if ( (LA147_0==62) ) {
                alt147=1;
            }
            switch (alt147) {
                case 1 :
                    // InternalQVTbase.g:13955:2: rule__TypeNameExpCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeNameExpCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__0"
    // InternalQVTbase.g:13969:1: rule__TypeNameExpCS__Group_1__0 : rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 ;
    public final void rule__TypeNameExpCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13973:1: ( rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1 )
            // InternalQVTbase.g:13974:2: rule__TypeNameExpCS__Group_1__0__Impl rule__TypeNameExpCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__TypeNameExpCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__0"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__0__Impl"
    // InternalQVTbase.g:13981:1: rule__TypeNameExpCS__Group_1__0__Impl : ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) ;
    public final void rule__TypeNameExpCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:13985:1: ( ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) ) )
            // InternalQVTbase.g:13986:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            {
            // InternalQVTbase.g:13986:1: ( ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 ) )
            // InternalQVTbase.g:13987:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0());
            }
            // InternalQVTbase.g:13988:1: ( rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 )
            // InternalQVTbase.g:13988:2: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__1"
    // InternalQVTbase.g:13998:1: rule__TypeNameExpCS__Group_1__1 : rule__TypeNameExpCS__Group_1__1__Impl ;
    public final void rule__TypeNameExpCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14002:1: ( rule__TypeNameExpCS__Group_1__1__Impl )
            // InternalQVTbase.g:14003:2: rule__TypeNameExpCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__1"


    // $ANTLR start "rule__TypeNameExpCS__Group_1__1__Impl"
    // InternalQVTbase.g:14009:1: rule__TypeNameExpCS__Group_1__1__Impl : ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) ;
    public final void rule__TypeNameExpCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14013:1: ( ( ( rule__TypeNameExpCS__Group_1_1__0 )? ) )
            // InternalQVTbase.g:14014:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            {
            // InternalQVTbase.g:14014:1: ( ( rule__TypeNameExpCS__Group_1_1__0 )? )
            // InternalQVTbase.g:14015:1: ( rule__TypeNameExpCS__Group_1_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1());
            }
            // InternalQVTbase.g:14016:1: ( rule__TypeNameExpCS__Group_1_1__0 )?
            int alt148=2;
            int LA148_0 = input.LA(1);

            if ( (LA148_0==62) ) {
                alt148=1;
            }
            switch (alt148) {
                case 1 :
                    // InternalQVTbase.g:14016:2: rule__TypeNameExpCS__Group_1_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeNameExpCS__Group_1_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getGroup_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0"
    // InternalQVTbase.g:14030:1: rule__TypeNameExpCS__Group_1_1__0 : rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 ;
    public final void rule__TypeNameExpCS__Group_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14034:1: ( rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1 )
            // InternalQVTbase.g:14035:2: rule__TypeNameExpCS__Group_1_1__0__Impl rule__TypeNameExpCS__Group_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__TypeNameExpCS__Group_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__0"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__0__Impl"
    // InternalQVTbase.g:14042:1: rule__TypeNameExpCS__Group_1_1__0__Impl : ( '{' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14046:1: ( ( '{' ) )
            // InternalQVTbase.g:14047:1: ( '{' )
            {
            // InternalQVTbase.g:14047:1: ( '{' )
            // InternalQVTbase.g:14048:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getLeftCurlyBracketKeyword_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__0__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1"
    // InternalQVTbase.g:14061:1: rule__TypeNameExpCS__Group_1_1__1 : rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 ;
    public final void rule__TypeNameExpCS__Group_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14065:1: ( rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2 )
            // InternalQVTbase.g:14066:2: rule__TypeNameExpCS__Group_1_1__1__Impl rule__TypeNameExpCS__Group_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_12);
            rule__TypeNameExpCS__Group_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__1"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__1__Impl"
    // InternalQVTbase.g:14073:1: rule__TypeNameExpCS__Group_1_1__1__Impl : ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) ;
    public final void rule__TypeNameExpCS__Group_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14077:1: ( ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) ) )
            // InternalQVTbase.g:14078:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            {
            // InternalQVTbase.g:14078:1: ( ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 ) )
            // InternalQVTbase.g:14079:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1());
            }
            // InternalQVTbase.g:14080:1: ( rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 )
            // InternalQVTbase.g:14080:2: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardAssignment_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__1__Impl"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2"
    // InternalQVTbase.g:14090:1: rule__TypeNameExpCS__Group_1_1__2 : rule__TypeNameExpCS__Group_1_1__2__Impl ;
    public final void rule__TypeNameExpCS__Group_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14094:1: ( rule__TypeNameExpCS__Group_1_1__2__Impl )
            // InternalQVTbase.g:14095:2: rule__TypeNameExpCS__Group_1_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeNameExpCS__Group_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2"


    // $ANTLR start "rule__TypeNameExpCS__Group_1_1__2__Impl"
    // InternalQVTbase.g:14101:1: rule__TypeNameExpCS__Group_1_1__2__Impl : ( '}' ) ;
    public final void rule__TypeNameExpCS__Group_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14105:1: ( ( '}' ) )
            // InternalQVTbase.g:14106:1: ( '}' )
            {
            // InternalQVTbase.g:14106:1: ( '}' )
            // InternalQVTbase.g:14107:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getRightCurlyBracketKeyword_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__Group_1_1__2__Impl"


    // $ANTLR start "rule__TypeExpCS__Group__0"
    // InternalQVTbase.g:14126:1: rule__TypeExpCS__Group__0 : rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 ;
    public final void rule__TypeExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14130:1: ( rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1 )
            // InternalQVTbase.g:14131:2: rule__TypeExpCS__Group__0__Impl rule__TypeExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_54);
            rule__TypeExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__0"


    // $ANTLR start "rule__TypeExpCS__Group__0__Impl"
    // InternalQVTbase.g:14138:1: rule__TypeExpCS__Group__0__Impl : ( ruleTypeExpWithoutMultiplicityCS ) ;
    public final void rule__TypeExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14142:1: ( ( ruleTypeExpWithoutMultiplicityCS ) )
            // InternalQVTbase.g:14143:1: ( ruleTypeExpWithoutMultiplicityCS )
            {
            // InternalQVTbase.g:14143:1: ( ruleTypeExpWithoutMultiplicityCS )
            // InternalQVTbase.g:14144:1: ruleTypeExpWithoutMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpWithoutMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getTypeExpWithoutMultiplicityCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__0__Impl"


    // $ANTLR start "rule__TypeExpCS__Group__1"
    // InternalQVTbase.g:14155:1: rule__TypeExpCS__Group__1 : rule__TypeExpCS__Group__1__Impl ;
    public final void rule__TypeExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14159:1: ( rule__TypeExpCS__Group__1__Impl )
            // InternalQVTbase.g:14160:2: rule__TypeExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__1"


    // $ANTLR start "rule__TypeExpCS__Group__1__Impl"
    // InternalQVTbase.g:14166:1: rule__TypeExpCS__Group__1__Impl : ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) ;
    public final void rule__TypeExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14170:1: ( ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? ) )
            // InternalQVTbase.g:14171:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            {
            // InternalQVTbase.g:14171:1: ( ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )? )
            // InternalQVTbase.g:14172:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1());
            }
            // InternalQVTbase.g:14173:1: ( rule__TypeExpCS__OwnedMultiplicityAssignment_1 )?
            int alt149=2;
            int LA149_0 = input.LA(1);

            if ( (LA149_0==87) ) {
                alt149=1;
            }
            switch (alt149) {
                case 1 :
                    // InternalQVTbase.g:14173:2: rule__TypeExpCS__OwnedMultiplicityAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeExpCS__OwnedMultiplicityAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__Group__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0__0"
    // InternalQVTbase.g:14187:1: rule__ExpCS__Group_0__0 : rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 ;
    public final void rule__ExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14191:1: ( rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1 )
            // InternalQVTbase.g:14192:2: rule__ExpCS__Group_0__0__Impl rule__ExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_72);
            rule__ExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__0"


    // $ANTLR start "rule__ExpCS__Group_0__0__Impl"
    // InternalQVTbase.g:14199:1: rule__ExpCS__Group_0__0__Impl : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__ExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14203:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalQVTbase.g:14204:1: ( rulePrefixedPrimaryExpCS )
            {
            // InternalQVTbase.g:14204:1: ( rulePrefixedPrimaryExpCS )
            // InternalQVTbase.g:14205:1: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedPrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getPrefixedPrimaryExpCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__ExpCS__Group_0__1"
    // InternalQVTbase.g:14216:1: rule__ExpCS__Group_0__1 : rule__ExpCS__Group_0__1__Impl ;
    public final void rule__ExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14220:1: ( rule__ExpCS__Group_0__1__Impl )
            // InternalQVTbase.g:14221:2: rule__ExpCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__1"


    // $ANTLR start "rule__ExpCS__Group_0__1__Impl"
    // InternalQVTbase.g:14227:1: rule__ExpCS__Group_0__1__Impl : ( ( rule__ExpCS__Group_0_1__0 )? ) ;
    public final void rule__ExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14231:1: ( ( ( rule__ExpCS__Group_0_1__0 )? ) )
            // InternalQVTbase.g:14232:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            {
            // InternalQVTbase.g:14232:1: ( ( rule__ExpCS__Group_0_1__0 )? )
            // InternalQVTbase.g:14233:1: ( rule__ExpCS__Group_0_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getGroup_0_1());
            }
            // InternalQVTbase.g:14234:1: ( rule__ExpCS__Group_0_1__0 )?
            int alt150=2;
            int LA150_0 = input.LA(1);

            if ( (LA150_0==19||(LA150_0>=22 && LA150_0<=42)) ) {
                alt150=1;
            }
            switch (alt150) {
                case 1 :
                    // InternalQVTbase.g:14234:2: rule__ExpCS__Group_0_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__ExpCS__Group_0_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getGroup_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__0"
    // InternalQVTbase.g:14248:1: rule__ExpCS__Group_0_1__0 : rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 ;
    public final void rule__ExpCS__Group_0_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14252:1: ( rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1 )
            // InternalQVTbase.g:14253:2: rule__ExpCS__Group_0_1__0__Impl rule__ExpCS__Group_0_1__1
            {
            pushFollow(FollowSets000.FOLLOW_72);
            rule__ExpCS__Group_0_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__0"


    // $ANTLR start "rule__ExpCS__Group_0_1__0__Impl"
    // InternalQVTbase.g:14260:1: rule__ExpCS__Group_0_1__0__Impl : ( () ) ;
    public final void rule__ExpCS__Group_0_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14264:1: ( ( () ) )
            // InternalQVTbase.g:14265:1: ( () )
            {
            // InternalQVTbase.g:14265:1: ( () )
            // InternalQVTbase.g:14266:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0());
            }
            // InternalQVTbase.g:14267:1: ()
            // InternalQVTbase.g:14269:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getInfixExpCSOwnedLeftAction_0_1_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__0__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__1"
    // InternalQVTbase.g:14279:1: rule__ExpCS__Group_0_1__1 : rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 ;
    public final void rule__ExpCS__Group_0_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14283:1: ( rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2 )
            // InternalQVTbase.g:14284:2: rule__ExpCS__Group_0_1__1__Impl rule__ExpCS__Group_0_1__2
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__ExpCS__Group_0_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__1"


    // $ANTLR start "rule__ExpCS__Group_0_1__1__Impl"
    // InternalQVTbase.g:14291:1: rule__ExpCS__Group_0_1__1__Impl : ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) ;
    public final void rule__ExpCS__Group_0_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14295:1: ( ( ( rule__ExpCS__NameAssignment_0_1_1 ) ) )
            // InternalQVTbase.g:14296:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            {
            // InternalQVTbase.g:14296:1: ( ( rule__ExpCS__NameAssignment_0_1_1 ) )
            // InternalQVTbase.g:14297:1: ( rule__ExpCS__NameAssignment_0_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1());
            }
            // InternalQVTbase.g:14298:1: ( rule__ExpCS__NameAssignment_0_1_1 )
            // InternalQVTbase.g:14298:2: rule__ExpCS__NameAssignment_0_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__NameAssignment_0_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getNameAssignment_0_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__1__Impl"


    // $ANTLR start "rule__ExpCS__Group_0_1__2"
    // InternalQVTbase.g:14308:1: rule__ExpCS__Group_0_1__2 : rule__ExpCS__Group_0_1__2__Impl ;
    public final void rule__ExpCS__Group_0_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14312:1: ( rule__ExpCS__Group_0_1__2__Impl )
            // InternalQVTbase.g:14313:2: rule__ExpCS__Group_0_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__Group_0_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__2"


    // $ANTLR start "rule__ExpCS__Group_0_1__2__Impl"
    // InternalQVTbase.g:14319:1: rule__ExpCS__Group_0_1__2__Impl : ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) ;
    public final void rule__ExpCS__Group_0_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14323:1: ( ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) ) )
            // InternalQVTbase.g:14324:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            {
            // InternalQVTbase.g:14324:1: ( ( rule__ExpCS__OwnedRightAssignment_0_1_2 ) )
            // InternalQVTbase.g:14325:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2());
            }
            // InternalQVTbase.g:14326:1: ( rule__ExpCS__OwnedRightAssignment_0_1_2 )
            // InternalQVTbase.g:14326:2: rule__ExpCS__OwnedRightAssignment_0_1_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ExpCS__OwnedRightAssignment_0_1_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getOwnedRightAssignment_0_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__Group_0_1__2__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0"
    // InternalQVTbase.g:14342:1: rule__PrefixedLetExpCS__Group_0__0 : rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 ;
    public final void rule__PrefixedLetExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14346:1: ( rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1 )
            // InternalQVTbase.g:14347:2: rule__PrefixedLetExpCS__Group_0__0__Impl rule__PrefixedLetExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_73);
            rule__PrefixedLetExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__0__Impl"
    // InternalQVTbase.g:14354:1: rule__PrefixedLetExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedLetExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14358:1: ( ( () ) )
            // InternalQVTbase.g:14359:1: ( () )
            {
            // InternalQVTbase.g:14359:1: ( () )
            // InternalQVTbase.g:14360:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0());
            }
            // InternalQVTbase.g:14361:1: ()
            // InternalQVTbase.g:14363:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getPrefixExpCSAction_0_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1"
    // InternalQVTbase.g:14373:1: rule__PrefixedLetExpCS__Group_0__1 : rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 ;
    public final void rule__PrefixedLetExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14377:1: ( rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2 )
            // InternalQVTbase.g:14378:2: rule__PrefixedLetExpCS__Group_0__1__Impl rule__PrefixedLetExpCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__PrefixedLetExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__1__Impl"
    // InternalQVTbase.g:14385:1: rule__PrefixedLetExpCS__Group_0__1__Impl : ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) ;
    public final void rule__PrefixedLetExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14389:1: ( ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) ) )
            // InternalQVTbase.g:14390:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            {
            // InternalQVTbase.g:14390:1: ( ( rule__PrefixedLetExpCS__NameAssignment_0_1 ) )
            // InternalQVTbase.g:14391:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1());
            }
            // InternalQVTbase.g:14392:1: ( rule__PrefixedLetExpCS__NameAssignment_0_1 )
            // InternalQVTbase.g:14392:2: rule__PrefixedLetExpCS__NameAssignment_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getNameAssignment_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2"
    // InternalQVTbase.g:14402:1: rule__PrefixedLetExpCS__Group_0__2 : rule__PrefixedLetExpCS__Group_0__2__Impl ;
    public final void rule__PrefixedLetExpCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14406:1: ( rule__PrefixedLetExpCS__Group_0__2__Impl )
            // InternalQVTbase.g:14407:2: rule__PrefixedLetExpCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2"


    // $ANTLR start "rule__PrefixedLetExpCS__Group_0__2__Impl"
    // InternalQVTbase.g:14413:1: rule__PrefixedLetExpCS__Group_0__2__Impl : ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) ;
    public final void rule__PrefixedLetExpCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14417:1: ( ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalQVTbase.g:14418:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalQVTbase.g:14418:1: ( ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 ) )
            // InternalQVTbase.g:14419:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2());
            }
            // InternalQVTbase.g:14420:1: ( rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 )
            // InternalQVTbase.g:14420:2: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedLetExpCS__OwnedRightAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__Group_0__2__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0"
    // InternalQVTbase.g:14436:1: rule__PrefixedPrimaryExpCS__Group_0__0 : rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14440:1: ( rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1 )
            // InternalQVTbase.g:14441:2: rule__PrefixedPrimaryExpCS__Group_0__0__Impl rule__PrefixedPrimaryExpCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_73);
            rule__PrefixedPrimaryExpCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__0__Impl"
    // InternalQVTbase.g:14448:1: rule__PrefixedPrimaryExpCS__Group_0__0__Impl : ( () ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14452:1: ( ( () ) )
            // InternalQVTbase.g:14453:1: ( () )
            {
            // InternalQVTbase.g:14453:1: ( () )
            // InternalQVTbase.g:14454:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0());
            }
            // InternalQVTbase.g:14455:1: ()
            // InternalQVTbase.g:14457:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getPrefixExpCSAction_0_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__0__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1"
    // InternalQVTbase.g:14467:1: rule__PrefixedPrimaryExpCS__Group_0__1 : rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14471:1: ( rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2 )
            // InternalQVTbase.g:14472:2: rule__PrefixedPrimaryExpCS__Group_0__1__Impl rule__PrefixedPrimaryExpCS__Group_0__2
            {
            pushFollow(FollowSets000.FOLLOW_74);
            rule__PrefixedPrimaryExpCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__1__Impl"
    // InternalQVTbase.g:14479:1: rule__PrefixedPrimaryExpCS__Group_0__1__Impl : ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14483:1: ( ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) ) )
            // InternalQVTbase.g:14484:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            {
            // InternalQVTbase.g:14484:1: ( ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 ) )
            // InternalQVTbase.g:14485:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1());
            }
            // InternalQVTbase.g:14486:1: ( rule__PrefixedPrimaryExpCS__NameAssignment_0_1 )
            // InternalQVTbase.g:14486:2: rule__PrefixedPrimaryExpCS__NameAssignment_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__NameAssignment_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameAssignment_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__1__Impl"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2"
    // InternalQVTbase.g:14496:1: rule__PrefixedPrimaryExpCS__Group_0__2 : rule__PrefixedPrimaryExpCS__Group_0__2__Impl ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14500:1: ( rule__PrefixedPrimaryExpCS__Group_0__2__Impl )
            // InternalQVTbase.g:14501:2: rule__PrefixedPrimaryExpCS__Group_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__Group_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__Group_0__2__Impl"
    // InternalQVTbase.g:14507:1: rule__PrefixedPrimaryExpCS__Group_0__2__Impl : ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) ;
    public final void rule__PrefixedPrimaryExpCS__Group_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14511:1: ( ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) ) )
            // InternalQVTbase.g:14512:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            {
            // InternalQVTbase.g:14512:1: ( ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 ) )
            // InternalQVTbase.g:14513:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2());
            }
            // InternalQVTbase.g:14514:1: ( rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 )
            // InternalQVTbase.g:14514:2: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightAssignment_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__Group_0__2__Impl"


    // $ANTLR start "rule__NameExpCS__Group__0"
    // InternalQVTbase.g:14530: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 {
            // InternalQVTbase.g:14534:1: ( rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1 )
            // InternalQVTbase.g:14535:2: rule__NameExpCS__Group__0__Impl rule__NameExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_75);
            rule__NameExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__0"


    // $ANTLR start "rule__NameExpCS__Group__0__Impl"
    // InternalQVTbase.g:14542:1: rule__NameExpCS__Group__0__Impl : ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__NameExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14546:1: ( ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) ) )
            // InternalQVTbase.g:14547:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalQVTbase.g:14547:1: ( ( rule__NameExpCS__OwnedPathNameAssignment_0 ) )
            // InternalQVTbase.g:14548:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalQVTbase.g:14549:1: ( rule__NameExpCS__OwnedPathNameAssignment_0 )
            // InternalQVTbase.g:14549:2: rule__NameExpCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__0__Impl"


    // $ANTLR start "rule__NameExpCS__Group__1"
    // InternalQVTbase.g:14559:1: rule__NameExpCS__Group__1 : rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 ;
    public final void rule__NameExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14563:1: ( rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2 )
            // InternalQVTbase.g:14564:2: rule__NameExpCS__Group__1__Impl rule__NameExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_75);
            rule__NameExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__1"


    // $ANTLR start "rule__NameExpCS__Group__1__Impl"
    // InternalQVTbase.g:14571:1: rule__NameExpCS__Group__1__Impl : ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) ;
    public final void rule__NameExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14575:1: ( ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* ) )
            // InternalQVTbase.g:14576:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            {
            // InternalQVTbase.g:14576:1: ( ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )* )
            // InternalQVTbase.g:14577:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1());
            }
            // InternalQVTbase.g:14578:1: ( rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 )*
            loop151:
            do {
                int alt151=2;
                int LA151_0 = input.LA(1);

                if ( (LA151_0==87) ) {
                    alt151=1;
                }


                switch (alt151) {
            	case 1 :
            	    // InternalQVTbase.g:14578:2: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_76);
            	    rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop151;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__1__Impl"


    // $ANTLR start "rule__NameExpCS__Group__2"
    // InternalQVTbase.g:14588:1: rule__NameExpCS__Group__2 : rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 ;
    public final void rule__NameExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14592:1: ( rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3 )
            // InternalQVTbase.g:14593:2: rule__NameExpCS__Group__2__Impl rule__NameExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_75);
            rule__NameExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__2"


    // $ANTLR start "rule__NameExpCS__Group__2__Impl"
    // InternalQVTbase.g:14600:1: rule__NameExpCS__Group__2__Impl : ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) ;
    public final void rule__NameExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14604:1: ( ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? ) )
            // InternalQVTbase.g:14605:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            {
            // InternalQVTbase.g:14605:1: ( ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )? )
            // InternalQVTbase.g:14606:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2());
            }
            // InternalQVTbase.g:14607:1: ( rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 )?
            int alt152=2;
            int LA152_0 = input.LA(1);

            if ( (LA152_0==71) ) {
                alt152=1;
            }
            switch (alt152) {
                case 1 :
                    // InternalQVTbase.g:14607:2: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__2__Impl"


    // $ANTLR start "rule__NameExpCS__Group__3"
    // InternalQVTbase.g:14617:1: rule__NameExpCS__Group__3 : rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 ;
    public final void rule__NameExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14621:1: ( rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4 )
            // InternalQVTbase.g:14622:2: rule__NameExpCS__Group__3__Impl rule__NameExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_75);
            rule__NameExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__3"


    // $ANTLR start "rule__NameExpCS__Group__3__Impl"
    // InternalQVTbase.g:14629:1: rule__NameExpCS__Group__3__Impl : ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) ;
    public final void rule__NameExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14633:1: ( ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? ) )
            // InternalQVTbase.g:14634:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            {
            // InternalQVTbase.g:14634:1: ( ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )? )
            // InternalQVTbase.g:14635:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3());
            }
            // InternalQVTbase.g:14636:1: ( rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 )?
            int alt153=2;
            int LA153_0 = input.LA(1);

            if ( (LA153_0==62) ) {
                alt153=1;
            }
            switch (alt153) {
                case 1 :
                    // InternalQVTbase.g:14636:2: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__3__Impl"


    // $ANTLR start "rule__NameExpCS__Group__4"
    // InternalQVTbase.g:14646:1: rule__NameExpCS__Group__4 : rule__NameExpCS__Group__4__Impl ;
    public final void rule__NameExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14650:1: ( rule__NameExpCS__Group__4__Impl )
            // InternalQVTbase.g:14651:2: rule__NameExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__4"


    // $ANTLR start "rule__NameExpCS__Group__4__Impl"
    // InternalQVTbase.g:14657:1: rule__NameExpCS__Group__4__Impl : ( ( rule__NameExpCS__Group_4__0 )? ) ;
    public final void rule__NameExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14661:1: ( ( ( rule__NameExpCS__Group_4__0 )? ) )
            // InternalQVTbase.g:14662:1: ( ( rule__NameExpCS__Group_4__0 )? )
            {
            // InternalQVTbase.g:14662:1: ( ( rule__NameExpCS__Group_4__0 )? )
            // InternalQVTbase.g:14663:1: ( rule__NameExpCS__Group_4__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getGroup_4());
            }
            // InternalQVTbase.g:14664:1: ( rule__NameExpCS__Group_4__0 )?
            int alt154=2;
            int LA154_0 = input.LA(1);

            if ( (LA154_0==130) ) {
                alt154=1;
            }
            switch (alt154) {
                case 1 :
                    // InternalQVTbase.g:14664:2: rule__NameExpCS__Group_4__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NameExpCS__Group_4__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getGroup_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group__4__Impl"


    // $ANTLR start "rule__NameExpCS__Group_4__0"
    // InternalQVTbase.g:14684:1: rule__NameExpCS__Group_4__0 : rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 ;
    public final void rule__NameExpCS__Group_4__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14688:1: ( rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1 )
            // InternalQVTbase.g:14689:2: rule__NameExpCS__Group_4__0__Impl rule__NameExpCS__Group_4__1
            {
            pushFollow(FollowSets000.FOLLOW_77);
            rule__NameExpCS__Group_4__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group_4__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__0"


    // $ANTLR start "rule__NameExpCS__Group_4__0__Impl"
    // InternalQVTbase.g:14696:1: rule__NameExpCS__Group_4__0__Impl : ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) ;
    public final void rule__NameExpCS__Group_4__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14700:1: ( ( ( rule__NameExpCS__IsPreAssignment_4_0 ) ) )
            // InternalQVTbase.g:14701:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            {
            // InternalQVTbase.g:14701:1: ( ( rule__NameExpCS__IsPreAssignment_4_0 ) )
            // InternalQVTbase.g:14702:1: ( rule__NameExpCS__IsPreAssignment_4_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0());
            }
            // InternalQVTbase.g:14703:1: ( rule__NameExpCS__IsPreAssignment_4_0 )
            // InternalQVTbase.g:14703:2: rule__NameExpCS__IsPreAssignment_4_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__IsPreAssignment_4_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreAssignment_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__0__Impl"


    // $ANTLR start "rule__NameExpCS__Group_4__1"
    // InternalQVTbase.g:14713:1: rule__NameExpCS__Group_4__1 : rule__NameExpCS__Group_4__1__Impl ;
    public final void rule__NameExpCS__Group_4__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14717:1: ( rule__NameExpCS__Group_4__1__Impl )
            // InternalQVTbase.g:14718:2: rule__NameExpCS__Group_4__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NameExpCS__Group_4__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__1"


    // $ANTLR start "rule__NameExpCS__Group_4__1__Impl"
    // InternalQVTbase.g:14724:1: rule__NameExpCS__Group_4__1__Impl : ( 'pre' ) ;
    public final void rule__NameExpCS__Group_4__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14728:1: ( ( 'pre' ) )
            // InternalQVTbase.g:14729:1: ( 'pre' )
            {
            // InternalQVTbase.g:14729:1: ( 'pre' )
            // InternalQVTbase.g:14730:1: 'pre'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1());
            }
            match(input,86,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getPreKeyword_4_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__Group_4__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0"
    // InternalQVTbase.g:14747:1: rule__CurlyBracketedClauseCS__Group__0 : rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 ;
    public final void rule__CurlyBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14751:1: ( rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1 )
            // InternalQVTbase.g:14752:2: rule__CurlyBracketedClauseCS__Group__0__Impl rule__CurlyBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_58);
            rule__CurlyBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__0__Impl"
    // InternalQVTbase.g:14759:1: rule__CurlyBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__CurlyBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14763:1: ( ( () ) )
            // InternalQVTbase.g:14764:1: ( () )
            {
            // InternalQVTbase.g:14764:1: ( () )
            // InternalQVTbase.g:14765:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0());
            }
            // InternalQVTbase.g:14766:1: ()
            // InternalQVTbase.g:14768:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getCurlyBracketedClauseCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1"
    // InternalQVTbase.g:14778:1: rule__CurlyBracketedClauseCS__Group__1 : rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 ;
    public final void rule__CurlyBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14782:1: ( rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2 )
            // InternalQVTbase.g:14783:2: rule__CurlyBracketedClauseCS__Group__1__Impl rule__CurlyBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_78);
            rule__CurlyBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__1__Impl"
    // InternalQVTbase.g:14790:1: rule__CurlyBracketedClauseCS__Group__1__Impl : ( '{' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14794:1: ( ( '{' ) )
            // InternalQVTbase.g:14795:1: ( '{' )
            {
            // InternalQVTbase.g:14795:1: ( '{' )
            // InternalQVTbase.g:14796:1: '{'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1());
            }
            match(input,62,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getLeftCurlyBracketKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2"
    // InternalQVTbase.g:14809:1: rule__CurlyBracketedClauseCS__Group__2 : rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 ;
    public final void rule__CurlyBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14813:1: ( rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3 )
            // InternalQVTbase.g:14814:2: rule__CurlyBracketedClauseCS__Group__2__Impl rule__CurlyBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_78);
            rule__CurlyBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__2__Impl"
    // InternalQVTbase.g:14821:1: rule__CurlyBracketedClauseCS__Group__2__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) ;
    public final void rule__CurlyBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14825:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? ) )
            // InternalQVTbase.g:14826:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:14826:1: ( ( rule__CurlyBracketedClauseCS__Group_2__0 )? )
            // InternalQVTbase.g:14827:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:14828:1: ( rule__CurlyBracketedClauseCS__Group_2__0 )?
            int alt155=2;
            int LA155_0 = input.LA(1);

            if ( ((LA155_0>=RULE_SINGLE_QUOTED_STRING && LA155_0<=RULE_ESCAPED_ID)) ) {
                alt155=1;
            }
            switch (alt155) {
                case 1 :
                    // InternalQVTbase.g:14828:2: rule__CurlyBracketedClauseCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CurlyBracketedClauseCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3"
    // InternalQVTbase.g:14838:1: rule__CurlyBracketedClauseCS__Group__3 : rule__CurlyBracketedClauseCS__Group__3__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14842:1: ( rule__CurlyBracketedClauseCS__Group__3__Impl )
            // InternalQVTbase.g:14843:2: rule__CurlyBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group__3__Impl"
    // InternalQVTbase.g:14849:1: rule__CurlyBracketedClauseCS__Group__3__Impl : ( '}' ) ;
    public final void rule__CurlyBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14853:1: ( ( '}' ) )
            // InternalQVTbase.g:14854:1: ( '}' )
            {
            // InternalQVTbase.g:14854:1: ( '}' )
            // InternalQVTbase.g:14855:1: '}'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3());
            }
            match(input,63,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getRightCurlyBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0"
    // InternalQVTbase.g:14876:1: rule__CurlyBracketedClauseCS__Group_2__0 : rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14880:1: ( rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1 )
            // InternalQVTbase.g:14881:2: rule__CurlyBracketedClauseCS__Group_2__0__Impl rule__CurlyBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_14);
            rule__CurlyBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__0__Impl"
    // InternalQVTbase.g:14888:1: rule__CurlyBracketedClauseCS__Group_2__0__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14892:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) ) )
            // InternalQVTbase.g:14893:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) )
            {
            // InternalQVTbase.g:14893:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 ) )
            // InternalQVTbase.g:14894:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0());
            }
            // InternalQVTbase.g:14895:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 )
            // InternalQVTbase.g:14895:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1"
    // InternalQVTbase.g:14905:1: rule__CurlyBracketedClauseCS__Group_2__1 : rule__CurlyBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14909:1: ( rule__CurlyBracketedClauseCS__Group_2__1__Impl )
            // InternalQVTbase.g:14910:2: rule__CurlyBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2__1__Impl"
    // InternalQVTbase.g:14916:1: rule__CurlyBracketedClauseCS__Group_2__1__Impl : ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14920:1: ( ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* ) )
            // InternalQVTbase.g:14921:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* )
            {
            // InternalQVTbase.g:14921:1: ( ( rule__CurlyBracketedClauseCS__Group_2_1__0 )* )
            // InternalQVTbase.g:14922:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1());
            }
            // InternalQVTbase.g:14923:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0 )*
            loop156:
            do {
                int alt156=2;
                int LA156_0 = input.LA(1);

                if ( (LA156_0==64) ) {
                    alt156=1;
                }


                switch (alt156) {
            	case 1 :
            	    // InternalQVTbase.g:14923:2: rule__CurlyBracketedClauseCS__Group_2_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__CurlyBracketedClauseCS__Group_2_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop156;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getGroup_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0"
    // InternalQVTbase.g:14937:1: rule__CurlyBracketedClauseCS__Group_2_1__0 : rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14941:1: ( rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1 )
            // InternalQVTbase.g:14942:2: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl rule__CurlyBracketedClauseCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_79);
            rule__CurlyBracketedClauseCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:14949:1: rule__CurlyBracketedClauseCS__Group_2_1__0__Impl : ( ',' ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14953:1: ( ( ',' ) )
            // InternalQVTbase.g:14954:1: ( ',' )
            {
            // InternalQVTbase.g:14954:1: ( ',' )
            // InternalQVTbase.g:14955:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getCommaKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1"
    // InternalQVTbase.g:14968:1: rule__CurlyBracketedClauseCS__Group_2_1__1 : rule__CurlyBracketedClauseCS__Group_2_1__1__Impl ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14972:1: ( rule__CurlyBracketedClauseCS__Group_2_1__1__Impl )
            // InternalQVTbase.g:14973:2: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__1"


    // $ANTLR start "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:14979:1: rule__CurlyBracketedClauseCS__Group_2_1__1__Impl : ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) ;
    public final void rule__CurlyBracketedClauseCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:14983:1: ( ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) ) )
            // InternalQVTbase.g:14984:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) )
            {
            // InternalQVTbase.g:14984:1: ( ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 ) )
            // InternalQVTbase.g:14985:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1());
            }
            // InternalQVTbase.g:14986:1: ( rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 )
            // InternalQVTbase.g:14986:2: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__0"
    // InternalQVTbase.g:15000:1: rule__RoundBracketedClauseCS__Group__0 : rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 ;
    public final void rule__RoundBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15004:1: ( rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1 )
            // InternalQVTbase.g:15005:2: rule__RoundBracketedClauseCS__Group__0__Impl rule__RoundBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__RoundBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__0__Impl"
    // InternalQVTbase.g:15012:1: rule__RoundBracketedClauseCS__Group__0__Impl : ( () ) ;
    public final void rule__RoundBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15016:1: ( ( () ) )
            // InternalQVTbase.g:15017:1: ( () )
            {
            // InternalQVTbase.g:15017:1: ( () )
            // InternalQVTbase.g:15018:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0());
            }
            // InternalQVTbase.g:15019:1: ()
            // InternalQVTbase.g:15021:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getRoundBracketedClauseCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__1"
    // InternalQVTbase.g:15031:1: rule__RoundBracketedClauseCS__Group__1 : rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 ;
    public final void rule__RoundBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15035:1: ( rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2 )
            // InternalQVTbase.g:15036:2: rule__RoundBracketedClauseCS__Group__1__Impl rule__RoundBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_80);
            rule__RoundBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__1__Impl"
    // InternalQVTbase.g:15043:1: rule__RoundBracketedClauseCS__Group__1__Impl : ( '(' ) ;
    public final void rule__RoundBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15047:1: ( ( '(' ) )
            // InternalQVTbase.g:15048:1: ( '(' )
            {
            // InternalQVTbase.g:15048:1: ( '(' )
            // InternalQVTbase.g:15049:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getLeftParenthesisKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__2"
    // InternalQVTbase.g:15062:1: rule__RoundBracketedClauseCS__Group__2 : rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 ;
    public final void rule__RoundBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15066:1: ( rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3 )
            // InternalQVTbase.g:15067:2: rule__RoundBracketedClauseCS__Group__2__Impl rule__RoundBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_80);
            rule__RoundBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__2"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__2__Impl"
    // InternalQVTbase.g:15074:1: rule__RoundBracketedClauseCS__Group__2__Impl : ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) ;
    public final void rule__RoundBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15078:1: ( ( ( rule__RoundBracketedClauseCS__Group_2__0 )? ) )
            // InternalQVTbase.g:15079:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:15079:1: ( ( rule__RoundBracketedClauseCS__Group_2__0 )? )
            // InternalQVTbase.g:15080:1: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:15081:1: ( rule__RoundBracketedClauseCS__Group_2__0 )?
            int alt157=2;
            int LA157_0 = input.LA(1);

            if ( ((LA157_0>=RULE_INT && LA157_0<=RULE_ESCAPED_ID)||(LA157_0>=19 && LA157_0<=22)||(LA157_0>=43 && LA157_0<=57)||LA157_0==61||LA157_0==71||LA157_0==82||(LA157_0>=84 && LA157_0<=85)||LA157_0==90||(LA157_0>=95 && LA157_0<=96)||(LA157_0>=128 && LA157_0<=129)) ) {
                alt157=1;
            }
            switch (alt157) {
                case 1 :
                    // InternalQVTbase.g:15081:2: rule__RoundBracketedClauseCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__RoundBracketedClauseCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__3"
    // InternalQVTbase.g:15091:1: rule__RoundBracketedClauseCS__Group__3 : rule__RoundBracketedClauseCS__Group__3__Impl ;
    public final void rule__RoundBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15095:1: ( rule__RoundBracketedClauseCS__Group__3__Impl )
            // InternalQVTbase.g:15096:2: rule__RoundBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__3"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group__3__Impl"
    // InternalQVTbase.g:15102:1: rule__RoundBracketedClauseCS__Group__3__Impl : ( ')' ) ;
    public final void rule__RoundBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15106:1: ( ( ')' ) )
            // InternalQVTbase.g:15107:1: ( ')' )
            {
            // InternalQVTbase.g:15107:1: ( ')' )
            // InternalQVTbase.g:15108:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getRightParenthesisKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0"
    // InternalQVTbase.g:15129:1: rule__RoundBracketedClauseCS__Group_2__0 : rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 ;
    public final void rule__RoundBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15133:1: ( rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1 )
            // InternalQVTbase.g:15134:2: rule__RoundBracketedClauseCS__Group_2__0__Impl rule__RoundBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_81);
            rule__RoundBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__0__Impl"
    // InternalQVTbase.g:15141:1: rule__RoundBracketedClauseCS__Group_2__0__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15145:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) ) )
            // InternalQVTbase.g:15146:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            {
            // InternalQVTbase.g:15146:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 ) )
            // InternalQVTbase.g:15147:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0());
            }
            // InternalQVTbase.g:15148:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 )
            // InternalQVTbase.g:15148:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1"
    // InternalQVTbase.g:15158:1: rule__RoundBracketedClauseCS__Group_2__1 : rule__RoundBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__RoundBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15162:1: ( rule__RoundBracketedClauseCS__Group_2__1__Impl )
            // InternalQVTbase.g:15163:2: rule__RoundBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__RoundBracketedClauseCS__Group_2__1__Impl"
    // InternalQVTbase.g:15169:1: rule__RoundBracketedClauseCS__Group_2__1__Impl : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) ;
    public final void rule__RoundBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15173:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* ) )
            // InternalQVTbase.g:15174:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            {
            // InternalQVTbase.g:15174:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )* )
            // InternalQVTbase.g:15175:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1());
            }
            // InternalQVTbase.g:15176:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 )*
            loop158:
            do {
                int alt158=2;
                int LA158_0 = input.LA(1);

                if ( (LA158_0==17||LA158_0==64||LA158_0==131) ) {
                    alt158=1;
                }


                switch (alt158) {
            	case 1 :
            	    // InternalQVTbase.g:15176:2: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1
            	    {
            	    pushFollow(FollowSets000.FOLLOW_82);
            	    rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop158;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__0"
    // InternalQVTbase.g:15190:1: rule__SquareBracketedClauseCS__Group__0 : rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 ;
    public final void rule__SquareBracketedClauseCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15194:1: ( rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1 )
            // InternalQVTbase.g:15195:2: rule__SquareBracketedClauseCS__Group__0__Impl rule__SquareBracketedClauseCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__SquareBracketedClauseCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__0"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__0__Impl"
    // InternalQVTbase.g:15202:1: rule__SquareBracketedClauseCS__Group__0__Impl : ( '[' ) ;
    public final void rule__SquareBracketedClauseCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15206:1: ( ( '[' ) )
            // InternalQVTbase.g:15207:1: ( '[' )
            {
            // InternalQVTbase.g:15207:1: ( '[' )
            // InternalQVTbase.g:15208:1: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0());
            }
            match(input,87,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getLeftSquareBracketKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__0__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__1"
    // InternalQVTbase.g:15221:1: rule__SquareBracketedClauseCS__Group__1 : rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 ;
    public final void rule__SquareBracketedClauseCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15225:1: ( rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2 )
            // InternalQVTbase.g:15226:2: rule__SquareBracketedClauseCS__Group__1__Impl rule__SquareBracketedClauseCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_83);
            rule__SquareBracketedClauseCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__1"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__1__Impl"
    // InternalQVTbase.g:15233:1: rule__SquareBracketedClauseCS__Group__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) ;
    public final void rule__SquareBracketedClauseCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15237:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) ) )
            // InternalQVTbase.g:15238:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            {
            // InternalQVTbase.g:15238:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 ) )
            // InternalQVTbase.g:15239:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1());
            }
            // InternalQVTbase.g:15240:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 )
            // InternalQVTbase.g:15240:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__OwnedTermsAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__1__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__2"
    // InternalQVTbase.g:15250:1: rule__SquareBracketedClauseCS__Group__2 : rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 ;
    public final void rule__SquareBracketedClauseCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15254:1: ( rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3 )
            // InternalQVTbase.g:15255:2: rule__SquareBracketedClauseCS__Group__2__Impl rule__SquareBracketedClauseCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_83);
            rule__SquareBracketedClauseCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__2"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__2__Impl"
    // InternalQVTbase.g:15262:1: rule__SquareBracketedClauseCS__Group__2__Impl : ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) ;
    public final void rule__SquareBracketedClauseCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15266:1: ( ( ( rule__SquareBracketedClauseCS__Group_2__0 )* ) )
            // InternalQVTbase.g:15267:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            {
            // InternalQVTbase.g:15267:1: ( ( rule__SquareBracketedClauseCS__Group_2__0 )* )
            // InternalQVTbase.g:15268:1: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:15269:1: ( rule__SquareBracketedClauseCS__Group_2__0 )*
            loop159:
            do {
                int alt159=2;
                int LA159_0 = input.LA(1);

                if ( (LA159_0==64) ) {
                    alt159=1;
                }


                switch (alt159) {
            	case 1 :
            	    // InternalQVTbase.g:15269:2: rule__SquareBracketedClauseCS__Group_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__SquareBracketedClauseCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop159;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__2__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__3"
    // InternalQVTbase.g:15279:1: rule__SquareBracketedClauseCS__Group__3 : rule__SquareBracketedClauseCS__Group__3__Impl ;
    public final void rule__SquareBracketedClauseCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15283:1: ( rule__SquareBracketedClauseCS__Group__3__Impl )
            // InternalQVTbase.g:15284:2: rule__SquareBracketedClauseCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__3"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group__3__Impl"
    // InternalQVTbase.g:15290:1: rule__SquareBracketedClauseCS__Group__3__Impl : ( ']' ) ;
    public final void rule__SquareBracketedClauseCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15294:1: ( ( ']' ) )
            // InternalQVTbase.g:15295:1: ( ']' )
            {
            // InternalQVTbase.g:15295:1: ( ']' )
            // InternalQVTbase.g:15296:1: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3());
            }
            match(input,88,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getRightSquareBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group__3__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0"
    // InternalQVTbase.g:15317:1: rule__SquareBracketedClauseCS__Group_2__0 : rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 ;
    public final void rule__SquareBracketedClauseCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15321:1: ( rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1 )
            // InternalQVTbase.g:15322:2: rule__SquareBracketedClauseCS__Group_2__0__Impl rule__SquareBracketedClauseCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__SquareBracketedClauseCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__0__Impl"
    // InternalQVTbase.g:15329:1: rule__SquareBracketedClauseCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__SquareBracketedClauseCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15333:1: ( ( ',' ) )
            // InternalQVTbase.g:15334:1: ( ',' )
            {
            // InternalQVTbase.g:15334:1: ( ',' )
            // InternalQVTbase.g:15335:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getCommaKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__0__Impl"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1"
    // InternalQVTbase.g:15348:1: rule__SquareBracketedClauseCS__Group_2__1 : rule__SquareBracketedClauseCS__Group_2__1__Impl ;
    public final void rule__SquareBracketedClauseCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15352:1: ( rule__SquareBracketedClauseCS__Group_2__1__Impl )
            // InternalQVTbase.g:15353:2: rule__SquareBracketedClauseCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__1"


    // $ANTLR start "rule__SquareBracketedClauseCS__Group_2__1__Impl"
    // InternalQVTbase.g:15359:1: rule__SquareBracketedClauseCS__Group_2__1__Impl : ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) ;
    public final void rule__SquareBracketedClauseCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15363:1: ( ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) ) )
            // InternalQVTbase.g:15364:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            {
            // InternalQVTbase.g:15364:1: ( ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 ) )
            // InternalQVTbase.g:15365:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1());
            }
            // InternalQVTbase.g:15366:1: ( rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 )
            // InternalQVTbase.g:15366:2: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__0"
    // InternalQVTbase.g:15380:1: rule__NavigatingArgCS__Group_0__0 : rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 ;
    public final void rule__NavigatingArgCS__Group_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15384:1: ( rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1 )
            // InternalQVTbase.g:15385:2: rule__NavigatingArgCS__Group_0__0__Impl rule__NavigatingArgCS__Group_0__1
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingArgCS__Group_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__0__Impl"
    // InternalQVTbase.g:15392:1: rule__NavigatingArgCS__Group_0__0__Impl : ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) ;
    public final void rule__NavigatingArgCS__Group_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15396:1: ( ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) ) )
            // InternalQVTbase.g:15397:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            {
            // InternalQVTbase.g:15397:1: ( ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 ) )
            // InternalQVTbase.g:15398:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0());
            }
            // InternalQVTbase.g:15399:1: ( rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 )
            // InternalQVTbase.g:15399:2: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionAssignment_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__1"
    // InternalQVTbase.g:15409:1: rule__NavigatingArgCS__Group_0__1 : rule__NavigatingArgCS__Group_0__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15413:1: ( rule__NavigatingArgCS__Group_0__1__Impl )
            // InternalQVTbase.g:15414:2: rule__NavigatingArgCS__Group_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0__1__Impl"
    // InternalQVTbase.g:15420:1: rule__NavigatingArgCS__Group_0__1__Impl : ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) ;
    public final void rule__NavigatingArgCS__Group_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15424:1: ( ( ( rule__NavigatingArgCS__Alternatives_0_1 )? ) )
            // InternalQVTbase.g:15425:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            {
            // InternalQVTbase.g:15425:1: ( ( rule__NavigatingArgCS__Alternatives_0_1 )? )
            // InternalQVTbase.g:15426:1: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1());
            }
            // InternalQVTbase.g:15427:1: ( rule__NavigatingArgCS__Alternatives_0_1 )?
            int alt160=2;
            int LA160_0 = input.LA(1);

            if ( (LA160_0==61||LA160_0==83||LA160_0==89) ) {
                alt160=1;
            }
            switch (alt160) {
                case 1 :
                    // InternalQVTbase.g:15427:2: rule__NavigatingArgCS__Alternatives_0_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Alternatives_0_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getAlternatives_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0"
    // InternalQVTbase.g:15441:1: rule__NavigatingArgCS__Group_0_1_0__0 : rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15445:1: ( rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1 )
            // InternalQVTbase.g:15446:2: rule__NavigatingArgCS__Group_0_1_0__0__Impl rule__NavigatingArgCS__Group_0_1_0__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingArgCS__Group_0_1_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__0__Impl"
    // InternalQVTbase.g:15453:1: rule__NavigatingArgCS__Group_0_1_0__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15457:1: ( ( '<-' ) )
            // InternalQVTbase.g:15458:1: ( '<-' )
            {
            // InternalQVTbase.g:15458:1: ( '<-' )
            // InternalQVTbase.g:15459:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1"
    // InternalQVTbase.g:15472:1: rule__NavigatingArgCS__Group_0_1_0__1 : rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15476:1: ( rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2 )
            // InternalQVTbase.g:15477:2: rule__NavigatingArgCS__Group_0_1_0__1__Impl rule__NavigatingArgCS__Group_0_1_0__2
            {
            pushFollow(FollowSets000.FOLLOW_64);
            rule__NavigatingArgCS__Group_0_1_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__1__Impl"
    // InternalQVTbase.g:15484:1: rule__NavigatingArgCS__Group_0_1_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15488:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) ) )
            // InternalQVTbase.g:15489:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) )
            {
            // InternalQVTbase.g:15489:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 ) )
            // InternalQVTbase.g:15490:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1());
            }
            // InternalQVTbase.g:15491:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 )
            // InternalQVTbase.g:15491:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2"
    // InternalQVTbase.g:15501:1: rule__NavigatingArgCS__Group_0_1_0__2 : rule__NavigatingArgCS__Group_0_1_0__2__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15505:1: ( rule__NavigatingArgCS__Group_0_1_0__2__Impl )
            // InternalQVTbase.g:15506:2: rule__NavigatingArgCS__Group_0_1_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0__2__Impl"
    // InternalQVTbase.g:15512:1: rule__NavigatingArgCS__Group_0_1_0__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15516:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? ) )
            // InternalQVTbase.g:15517:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            {
            // InternalQVTbase.g:15517:1: ( ( rule__NavigatingArgCS__Group_0_1_0_2__0 )? )
            // InternalQVTbase.g:15518:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2());
            }
            // InternalQVTbase.g:15519:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0 )?
            int alt161=2;
            int LA161_0 = input.LA(1);

            if ( (LA161_0==29) ) {
                alt161=1;
            }
            switch (alt161) {
                case 1 :
                    // InternalQVTbase.g:15519:2: rule__NavigatingArgCS__Group_0_1_0_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_0_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0"
    // InternalQVTbase.g:15535:1: rule__NavigatingArgCS__Group_0_1_0_2__0 : rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15539:1: ( rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1 )
            // InternalQVTbase.g:15540:2: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl rule__NavigatingArgCS__Group_0_1_0_2__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingArgCS__Group_0_1_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl"
    // InternalQVTbase.g:15547:1: rule__NavigatingArgCS__Group_0_1_0_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15551:1: ( ( '=' ) )
            // InternalQVTbase.g:15552:1: ( '=' )
            {
            // InternalQVTbase.g:15552:1: ( '=' )
            // InternalQVTbase.g:15553:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1"
    // InternalQVTbase.g:15566:1: rule__NavigatingArgCS__Group_0_1_0_2__1 : rule__NavigatingArgCS__Group_0_1_0_2__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15570:1: ( rule__NavigatingArgCS__Group_0_1_0_2__1__Impl )
            // InternalQVTbase.g:15571:2: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_0_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl"
    // InternalQVTbase.g:15577:1: rule__NavigatingArgCS__Group_0_1_0_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_0_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15581:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) ) )
            // InternalQVTbase.g:15582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            {
            // InternalQVTbase.g:15582:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 ) )
            // InternalQVTbase.g:15583:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1());
            }
            // InternalQVTbase.g:15584:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 )
            // InternalQVTbase.g:15584:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_0_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_0_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0"
    // InternalQVTbase.g:15598:1: rule__NavigatingArgCS__Group_0_1_1__0 : rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15602:1: ( rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1 )
            // InternalQVTbase.g:15603:2: rule__NavigatingArgCS__Group_0_1_1__0__Impl rule__NavigatingArgCS__Group_0_1_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingArgCS__Group_0_1_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__0__Impl"
    // InternalQVTbase.g:15610:1: rule__NavigatingArgCS__Group_0_1_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15614:1: ( ( ':' ) )
            // InternalQVTbase.g:15615:1: ( ':' )
            {
            // InternalQVTbase.g:15615:1: ( ':' )
            // InternalQVTbase.g:15616:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1"
    // InternalQVTbase.g:15629:1: rule__NavigatingArgCS__Group_0_1_1__1 : rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15633:1: ( rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2 )
            // InternalQVTbase.g:15634:2: rule__NavigatingArgCS__Group_0_1_1__1__Impl rule__NavigatingArgCS__Group_0_1_1__2
            {
            pushFollow(FollowSets000.FOLLOW_85);
            rule__NavigatingArgCS__Group_0_1_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__1__Impl"
    // InternalQVTbase.g:15641:1: rule__NavigatingArgCS__Group_0_1_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15645:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) ) )
            // InternalQVTbase.g:15646:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) )
            {
            // InternalQVTbase.g:15646:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 ) )
            // InternalQVTbase.g:15647:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1());
            }
            // InternalQVTbase.g:15648:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 )
            // InternalQVTbase.g:15648:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2"
    // InternalQVTbase.g:15658:1: rule__NavigatingArgCS__Group_0_1_1__2 : rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 ;
    public final void rule__NavigatingArgCS__Group_0_1_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15662:1: ( rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3 )
            // InternalQVTbase.g:15663:2: rule__NavigatingArgCS__Group_0_1_1__2__Impl rule__NavigatingArgCS__Group_0_1_1__3
            {
            pushFollow(FollowSets000.FOLLOW_85);
            rule__NavigatingArgCS__Group_0_1_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__2__Impl"
    // InternalQVTbase.g:15670:1: rule__NavigatingArgCS__Group_0_1_1__2__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15674:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? ) )
            // InternalQVTbase.g:15675:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? )
            {
            // InternalQVTbase.g:15675:1: ( ( rule__NavigatingArgCS__Group_0_1_1_2__0 )? )
            // InternalQVTbase.g:15676:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2());
            }
            // InternalQVTbase.g:15677:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0 )?
            int alt162=2;
            int LA162_0 = input.LA(1);

            if ( (LA162_0==83) ) {
                alt162=1;
            }
            switch (alt162) {
                case 1 :
                    // InternalQVTbase.g:15677:2: rule__NavigatingArgCS__Group_0_1_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3"
    // InternalQVTbase.g:15687:1: rule__NavigatingArgCS__Group_0_1_1__3 : rule__NavigatingArgCS__Group_0_1_1__3__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15691:1: ( rule__NavigatingArgCS__Group_0_1_1__3__Impl )
            // InternalQVTbase.g:15692:2: rule__NavigatingArgCS__Group_0_1_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__3"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1__3__Impl"
    // InternalQVTbase.g:15698:1: rule__NavigatingArgCS__Group_0_1_1__3__Impl : ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15702:1: ( ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? ) )
            // InternalQVTbase.g:15703:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? )
            {
            // InternalQVTbase.g:15703:1: ( ( rule__NavigatingArgCS__Group_0_1_1_3__0 )? )
            // InternalQVTbase.g:15704:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3());
            }
            // InternalQVTbase.g:15705:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0 )?
            int alt163=2;
            int LA163_0 = input.LA(1);

            if ( (LA163_0==29) ) {
                alt163=1;
            }
            switch (alt163) {
                case 1 :
                    // InternalQVTbase.g:15705:2: rule__NavigatingArgCS__Group_0_1_1_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_1_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1__3__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0"
    // InternalQVTbase.g:15723:1: rule__NavigatingArgCS__Group_0_1_1_2__0 : rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15727:1: ( rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1 )
            // InternalQVTbase.g:15728:2: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingArgCS__Group_0_1_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl"
    // InternalQVTbase.g:15735:1: rule__NavigatingArgCS__Group_0_1_1_2__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15739:1: ( ( '<-' ) )
            // InternalQVTbase.g:15740:1: ( '<-' )
            {
            // InternalQVTbase.g:15740:1: ( '<-' )
            // InternalQVTbase.g:15741:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1"
    // InternalQVTbase.g:15754:1: rule__NavigatingArgCS__Group_0_1_1_2__1 : rule__NavigatingArgCS__Group_0_1_1_2__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15758:1: ( rule__NavigatingArgCS__Group_0_1_1_2__1__Impl )
            // InternalQVTbase.g:15759:2: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl"
    // InternalQVTbase.g:15765:1: rule__NavigatingArgCS__Group_0_1_1_2__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15769:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) ) )
            // InternalQVTbase.g:15770:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) )
            {
            // InternalQVTbase.g:15770:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 ) )
            // InternalQVTbase.g:15771:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1());
            }
            // InternalQVTbase.g:15772:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 )
            // InternalQVTbase.g:15772:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0"
    // InternalQVTbase.g:15786:1: rule__NavigatingArgCS__Group_0_1_1_3__0 : rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15790:1: ( rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1 )
            // InternalQVTbase.g:15791:2: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl rule__NavigatingArgCS__Group_0_1_1_3__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingArgCS__Group_0_1_1_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl"
    // InternalQVTbase.g:15798:1: rule__NavigatingArgCS__Group_0_1_1_3__0__Impl : ( '=' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15802:1: ( ( '=' ) )
            // InternalQVTbase.g:15803:1: ( '=' )
            {
            // InternalQVTbase.g:15803:1: ( '=' )
            // InternalQVTbase.g:15804:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getEqualsSignKeyword_0_1_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1"
    // InternalQVTbase.g:15817:1: rule__NavigatingArgCS__Group_0_1_1_3__1 : rule__NavigatingArgCS__Group_0_1_1_3__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15821:1: ( rule__NavigatingArgCS__Group_0_1_1_3__1__Impl )
            // InternalQVTbase.g:15822:2: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_1_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl"
    // InternalQVTbase.g:15828:1: rule__NavigatingArgCS__Group_0_1_1_3__1__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15832:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) ) )
            // InternalQVTbase.g:15833:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) )
            {
            // InternalQVTbase.g:15833:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 ) )
            // InternalQVTbase.g:15834:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1());
            }
            // InternalQVTbase.g:15835:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 )
            // InternalQVTbase.g:15835:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_1_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_1_3__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0"
    // InternalQVTbase.g:15849:1: rule__NavigatingArgCS__Group_0_1_2__0 : rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15853:1: ( rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1 )
            // InternalQVTbase.g:15854:2: rule__NavigatingArgCS__Group_0_1_2__0__Impl rule__NavigatingArgCS__Group_0_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingArgCS__Group_0_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__0__Impl"
    // InternalQVTbase.g:15861:1: rule__NavigatingArgCS__Group_0_1_2__0__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15865:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? ) )
            // InternalQVTbase.g:15866:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? )
            {
            // InternalQVTbase.g:15866:1: ( ( rule__NavigatingArgCS__Group_0_1_2_0__0 )? )
            // InternalQVTbase.g:15867:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0());
            }
            // InternalQVTbase.g:15868:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0 )?
            int alt164=2;
            int LA164_0 = input.LA(1);

            if ( (LA164_0==61) ) {
                alt164=1;
            }
            switch (alt164) {
                case 1 :
                    // InternalQVTbase.g:15868:2: rule__NavigatingArgCS__Group_0_1_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1"
    // InternalQVTbase.g:15878:1: rule__NavigatingArgCS__Group_0_1_2__1 : rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15882:1: ( rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2 )
            // InternalQVTbase.g:15883:2: rule__NavigatingArgCS__Group_0_1_2__1__Impl rule__NavigatingArgCS__Group_0_1_2__2
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingArgCS__Group_0_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__1__Impl"
    // InternalQVTbase.g:15890:1: rule__NavigatingArgCS__Group_0_1_2__1__Impl : ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15894:1: ( ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? ) )
            // InternalQVTbase.g:15895:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? )
            {
            // InternalQVTbase.g:15895:1: ( ( rule__NavigatingArgCS__Group_0_1_2_1__0 )? )
            // InternalQVTbase.g:15896:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1());
            }
            // InternalQVTbase.g:15897:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0 )?
            int alt165=2;
            int LA165_0 = input.LA(1);

            if ( (LA165_0==83) ) {
                alt165=1;
            }
            switch (alt165) {
                case 1 :
                    // InternalQVTbase.g:15897:2: rule__NavigatingArgCS__Group_0_1_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingArgCS__Group_0_1_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2"
    // InternalQVTbase.g:15907:1: rule__NavigatingArgCS__Group_0_1_2__2 : rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 ;
    public final void rule__NavigatingArgCS__Group_0_1_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15911:1: ( rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3 )
            // InternalQVTbase.g:15912:2: rule__NavigatingArgCS__Group_0_1_2__2__Impl rule__NavigatingArgCS__Group_0_1_2__3
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingArgCS__Group_0_1_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__2__Impl"
    // InternalQVTbase.g:15919:1: rule__NavigatingArgCS__Group_0_1_2__2__Impl : ( 'in' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15923:1: ( ( 'in' ) )
            // InternalQVTbase.g:15924:1: ( 'in' )
            {
            // InternalQVTbase.g:15924:1: ( 'in' )
            // InternalQVTbase.g:15925:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2());
            }
            match(input,89,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getInKeyword_0_1_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__2__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3"
    // InternalQVTbase.g:15938:1: rule__NavigatingArgCS__Group_0_1_2__3 : rule__NavigatingArgCS__Group_0_1_2__3__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15942:1: ( rule__NavigatingArgCS__Group_0_1_2__3__Impl )
            // InternalQVTbase.g:15943:2: rule__NavigatingArgCS__Group_0_1_2__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__3"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2__3__Impl"
    // InternalQVTbase.g:15949:1: rule__NavigatingArgCS__Group_0_1_2__3__Impl : ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15953:1: ( ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) ) )
            // InternalQVTbase.g:15954:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) )
            {
            // InternalQVTbase.g:15954:1: ( ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 ) )
            // InternalQVTbase.g:15955:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3());
            }
            // InternalQVTbase.g:15956:1: ( rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 )
            // InternalQVTbase.g:15956:2: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionAssignment_0_1_2_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2__3__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0"
    // InternalQVTbase.g:15974:1: rule__NavigatingArgCS__Group_0_1_2_0__0 : rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15978:1: ( rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1 )
            // InternalQVTbase.g:15979:2: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl rule__NavigatingArgCS__Group_0_1_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingArgCS__Group_0_1_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl"
    // InternalQVTbase.g:15986:1: rule__NavigatingArgCS__Group_0_1_2_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:15990:1: ( ( ':' ) )
            // InternalQVTbase.g:15991:1: ( ':' )
            {
            // InternalQVTbase.g:15991:1: ( ':' )
            // InternalQVTbase.g:15992:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_0_1_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1"
    // InternalQVTbase.g:16005:1: rule__NavigatingArgCS__Group_0_1_2_0__1 : rule__NavigatingArgCS__Group_0_1_2_0__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16009:1: ( rule__NavigatingArgCS__Group_0_1_2_0__1__Impl )
            // InternalQVTbase.g:16010:2: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl"
    // InternalQVTbase.g:16016:1: rule__NavigatingArgCS__Group_0_1_2_0__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16020:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) ) )
            // InternalQVTbase.g:16021:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) )
            {
            // InternalQVTbase.g:16021:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 ) )
            // InternalQVTbase.g:16022:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1());
            }
            // InternalQVTbase.g:16023:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 )
            // InternalQVTbase.g:16023:2: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_0_1_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0"
    // InternalQVTbase.g:16037:1: rule__NavigatingArgCS__Group_0_1_2_1__0 : rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16041:1: ( rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1 )
            // InternalQVTbase.g:16042:2: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl rule__NavigatingArgCS__Group_0_1_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingArgCS__Group_0_1_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl"
    // InternalQVTbase.g:16049:1: rule__NavigatingArgCS__Group_0_1_2_1__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16053:1: ( ( '<-' ) )
            // InternalQVTbase.g:16054:1: ( '<-' )
            {
            // InternalQVTbase.g:16054:1: ( '<-' )
            // InternalQVTbase.g:16055:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getLessThanSignHyphenMinusKeyword_0_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1"
    // InternalQVTbase.g:16068:1: rule__NavigatingArgCS__Group_0_1_2_1__1 : rule__NavigatingArgCS__Group_0_1_2_1__1__Impl ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16072:1: ( rule__NavigatingArgCS__Group_0_1_2_1__1__Impl )
            // InternalQVTbase.g:16073:2: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_0_1_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl"
    // InternalQVTbase.g:16079:1: rule__NavigatingArgCS__Group_0_1_2_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_0_1_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16083:1: ( ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) ) )
            // InternalQVTbase.g:16084:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) )
            {
            // InternalQVTbase.g:16084:1: ( ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 ) )
            // InternalQVTbase.g:16085:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1());
            }
            // InternalQVTbase.g:16086:1: ( rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 )
            // InternalQVTbase.g:16086:2: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorAssignment_0_1_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_0_1_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__0"
    // InternalQVTbase.g:16100:1: rule__NavigatingArgCS__Group_1__0 : rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 ;
    public final void rule__NavigatingArgCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16104:1: ( rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1 )
            // InternalQVTbase.g:16105:2: rule__NavigatingArgCS__Group_1__0__Impl rule__NavigatingArgCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingArgCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__0"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__0__Impl"
    // InternalQVTbase.g:16112:1: rule__NavigatingArgCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingArgCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16116:1: ( ( ':' ) )
            // InternalQVTbase.g:16117:1: ( ':' )
            {
            // InternalQVTbase.g:16117:1: ( ':' )
            // InternalQVTbase.g:16118:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__0__Impl"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__1"
    // InternalQVTbase.g:16131:1: rule__NavigatingArgCS__Group_1__1 : rule__NavigatingArgCS__Group_1__1__Impl ;
    public final void rule__NavigatingArgCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16135:1: ( rule__NavigatingArgCS__Group_1__1__Impl )
            // InternalQVTbase.g:16136:2: rule__NavigatingArgCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__1"


    // $ANTLR start "rule__NavigatingArgCS__Group_1__1__Impl"
    // InternalQVTbase.g:16142:1: rule__NavigatingArgCS__Group_1__1__Impl : ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__NavigatingArgCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16146:1: ( ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:16147:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:16147:1: ( ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 ) )
            // InternalQVTbase.g:16148:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalQVTbase.g:16149:1: ( rule__NavigatingArgCS__OwnedTypeAssignment_1_1 )
            // InternalQVTbase.g:16149:2: rule__NavigatingArgCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingArgCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__Group_1__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__0"
    // InternalQVTbase.g:16163:1: rule__NavigatingBarArgCS__Group__0 : rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 ;
    public final void rule__NavigatingBarArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16167:1: ( rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1 )
            // InternalQVTbase.g:16168:2: rule__NavigatingBarArgCS__Group__0__Impl rule__NavigatingBarArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingBarArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__0__Impl"
    // InternalQVTbase.g:16175:1: rule__NavigatingBarArgCS__Group__0__Impl : ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16179:1: ( ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) ) )
            // InternalQVTbase.g:16180:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            {
            // InternalQVTbase.g:16180:1: ( ( rule__NavigatingBarArgCS__PrefixAssignment_0 ) )
            // InternalQVTbase.g:16181:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0());
            }
            // InternalQVTbase.g:16182:1: ( rule__NavigatingBarArgCS__PrefixAssignment_0 )
            // InternalQVTbase.g:16182:2: rule__NavigatingBarArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__1"
    // InternalQVTbase.g:16192:1: rule__NavigatingBarArgCS__Group__1 : rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 ;
    public final void rule__NavigatingBarArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16196:1: ( rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2 )
            // InternalQVTbase.g:16197:2: rule__NavigatingBarArgCS__Group__1__Impl rule__NavigatingBarArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__NavigatingBarArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__1__Impl"
    // InternalQVTbase.g:16204:1: rule__NavigatingBarArgCS__Group__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16208:1: ( ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalQVTbase.g:16209:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalQVTbase.g:16209:1: ( ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalQVTbase.g:16210:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalQVTbase.g:16211:1: ( rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 )
            // InternalQVTbase.g:16211:2: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__2"
    // InternalQVTbase.g:16221:1: rule__NavigatingBarArgCS__Group__2 : rule__NavigatingBarArgCS__Group__2__Impl ;
    public final void rule__NavigatingBarArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16225:1: ( rule__NavigatingBarArgCS__Group__2__Impl )
            // InternalQVTbase.g:16226:2: rule__NavigatingBarArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__2"


    // $ANTLR start "rule__NavigatingBarArgCS__Group__2__Impl"
    // InternalQVTbase.g:16232:1: rule__NavigatingBarArgCS__Group__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) ;
    public final void rule__NavigatingBarArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16236:1: ( ( ( rule__NavigatingBarArgCS__Group_2__0 )? ) )
            // InternalQVTbase.g:16237:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:16237:1: ( ( rule__NavigatingBarArgCS__Group_2__0 )? )
            // InternalQVTbase.g:16238:1: ( rule__NavigatingBarArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:16239:1: ( rule__NavigatingBarArgCS__Group_2__0 )?
            int alt166=2;
            int LA166_0 = input.LA(1);

            if ( (LA166_0==61) ) {
                alt166=1;
            }
            switch (alt166) {
                case 1 :
                    // InternalQVTbase.g:16239:2: rule__NavigatingBarArgCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingBarArgCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0"
    // InternalQVTbase.g:16255:1: rule__NavigatingBarArgCS__Group_2__0 : rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 ;
    public final void rule__NavigatingBarArgCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16259:1: ( rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1 )
            // InternalQVTbase.g:16260:2: rule__NavigatingBarArgCS__Group_2__0__Impl rule__NavigatingBarArgCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingBarArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__0__Impl"
    // InternalQVTbase.g:16267:1: rule__NavigatingBarArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingBarArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16271:1: ( ( ':' ) )
            // InternalQVTbase.g:16272:1: ( ':' )
            {
            // InternalQVTbase.g:16272:1: ( ':' )
            // InternalQVTbase.g:16273:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1"
    // InternalQVTbase.g:16286:1: rule__NavigatingBarArgCS__Group_2__1 : rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 ;
    public final void rule__NavigatingBarArgCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16290:1: ( rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2 )
            // InternalQVTbase.g:16291:2: rule__NavigatingBarArgCS__Group_2__1__Impl rule__NavigatingBarArgCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_64);
            rule__NavigatingBarArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__1__Impl"
    // InternalQVTbase.g:16298:1: rule__NavigatingBarArgCS__Group_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16302:1: ( ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalQVTbase.g:16303:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalQVTbase.g:16303:1: ( ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalQVTbase.g:16304:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalQVTbase.g:16305:1: ( rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 )
            // InternalQVTbase.g:16305:2: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2"
    // InternalQVTbase.g:16315:1: rule__NavigatingBarArgCS__Group_2__2 : rule__NavigatingBarArgCS__Group_2__2__Impl ;
    public final void rule__NavigatingBarArgCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16319:1: ( rule__NavigatingBarArgCS__Group_2__2__Impl )
            // InternalQVTbase.g:16320:2: rule__NavigatingBarArgCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__2"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2__2__Impl"
    // InternalQVTbase.g:16326:1: rule__NavigatingBarArgCS__Group_2__2__Impl : ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) ;
    public final void rule__NavigatingBarArgCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16330:1: ( ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? ) )
            // InternalQVTbase.g:16331:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            {
            // InternalQVTbase.g:16331:1: ( ( rule__NavigatingBarArgCS__Group_2_2__0 )? )
            // InternalQVTbase.g:16332:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2());
            }
            // InternalQVTbase.g:16333:1: ( rule__NavigatingBarArgCS__Group_2_2__0 )?
            int alt167=2;
            int LA167_0 = input.LA(1);

            if ( (LA167_0==29) ) {
                alt167=1;
            }
            switch (alt167) {
                case 1 :
                    // InternalQVTbase.g:16333:2: rule__NavigatingBarArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingBarArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2__2__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0"
    // InternalQVTbase.g:16349:1: rule__NavigatingBarArgCS__Group_2_2__0 : rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 ;
    public final void rule__NavigatingBarArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16353:1: ( rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1 )
            // InternalQVTbase.g:16354:2: rule__NavigatingBarArgCS__Group_2_2__0__Impl rule__NavigatingBarArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingBarArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__0__Impl"
    // InternalQVTbase.g:16361:1: rule__NavigatingBarArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingBarArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16365:1: ( ( '=' ) )
            // InternalQVTbase.g:16366:1: ( '=' )
            {
            // InternalQVTbase.g:16366:1: ( '=' )
            // InternalQVTbase.g:16367:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getEqualsSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1"
    // InternalQVTbase.g:16380:1: rule__NavigatingBarArgCS__Group_2_2__1 : rule__NavigatingBarArgCS__Group_2_2__1__Impl ;
    public final void rule__NavigatingBarArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16384:1: ( rule__NavigatingBarArgCS__Group_2_2__1__Impl )
            // InternalQVTbase.g:16385:2: rule__NavigatingBarArgCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingBarArgCS__Group_2_2__1__Impl"
    // InternalQVTbase.g:16391:1: rule__NavigatingBarArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ;
    public final void rule__NavigatingBarArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16395:1: ( ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalQVTbase.g:16396:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalQVTbase.g:16396:1: ( ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalQVTbase.g:16397:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }
            // InternalQVTbase.g:16398:1: ( rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalQVTbase.g:16398:2: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__0"
    // InternalQVTbase.g:16412:1: rule__NavigatingCommaArgCS__Group__0 : rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 ;
    public final void rule__NavigatingCommaArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16416:1: ( rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1 )
            // InternalQVTbase.g:16417:2: rule__NavigatingCommaArgCS__Group__0__Impl rule__NavigatingCommaArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingCommaArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__0__Impl"
    // InternalQVTbase.g:16424:1: rule__NavigatingCommaArgCS__Group__0__Impl : ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16428:1: ( ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) ) )
            // InternalQVTbase.g:16429:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            {
            // InternalQVTbase.g:16429:1: ( ( rule__NavigatingCommaArgCS__PrefixAssignment_0 ) )
            // InternalQVTbase.g:16430:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0());
            }
            // InternalQVTbase.g:16431:1: ( rule__NavigatingCommaArgCS__PrefixAssignment_0 )
            // InternalQVTbase.g:16431:2: rule__NavigatingCommaArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__1"
    // InternalQVTbase.g:16441:1: rule__NavigatingCommaArgCS__Group__1 : rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 ;
    public final void rule__NavigatingCommaArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16445:1: ( rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2 )
            // InternalQVTbase.g:16446:2: rule__NavigatingCommaArgCS__Group__1__Impl rule__NavigatingCommaArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingCommaArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__1__Impl"
    // InternalQVTbase.g:16453:1: rule__NavigatingCommaArgCS__Group__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16457:1: ( ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalQVTbase.g:16458:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalQVTbase.g:16458:1: ( ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalQVTbase.g:16459:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalQVTbase.g:16460:1: ( rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 )
            // InternalQVTbase.g:16460:2: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__2"
    // InternalQVTbase.g:16470:1: rule__NavigatingCommaArgCS__Group__2 : rule__NavigatingCommaArgCS__Group__2__Impl ;
    public final void rule__NavigatingCommaArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16474:1: ( rule__NavigatingCommaArgCS__Group__2__Impl )
            // InternalQVTbase.g:16475:2: rule__NavigatingCommaArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group__2__Impl"
    // InternalQVTbase.g:16481:1: rule__NavigatingCommaArgCS__Group__2__Impl : ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16485:1: ( ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? ) )
            // InternalQVTbase.g:16486:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            {
            // InternalQVTbase.g:16486:1: ( ( rule__NavigatingCommaArgCS__Alternatives_2 )? )
            // InternalQVTbase.g:16487:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2());
            }
            // InternalQVTbase.g:16488:1: ( rule__NavigatingCommaArgCS__Alternatives_2 )?
            int alt168=2;
            int LA168_0 = input.LA(1);

            if ( (LA168_0==61||LA168_0==83||LA168_0==89) ) {
                alt168=1;
            }
            switch (alt168) {
                case 1 :
                    // InternalQVTbase.g:16488:2: rule__NavigatingCommaArgCS__Alternatives_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getAlternatives_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0"
    // InternalQVTbase.g:16504:1: rule__NavigatingCommaArgCS__Group_2_0__0 : rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16508:1: ( rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1 )
            // InternalQVTbase.g:16509:2: rule__NavigatingCommaArgCS__Group_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingCommaArgCS__Group_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__0__Impl"
    // InternalQVTbase.g:16516:1: rule__NavigatingCommaArgCS__Group_2_0__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16520:1: ( ( '<-' ) )
            // InternalQVTbase.g:16521:1: ( '<-' )
            {
            // InternalQVTbase.g:16521:1: ( '<-' )
            // InternalQVTbase.g:16522:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1"
    // InternalQVTbase.g:16535:1: rule__NavigatingCommaArgCS__Group_2_0__1 : rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16539:1: ( rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2 )
            // InternalQVTbase.g:16540:2: rule__NavigatingCommaArgCS__Group_2_0__1__Impl rule__NavigatingCommaArgCS__Group_2_0__2
            {
            pushFollow(FollowSets000.FOLLOW_64);
            rule__NavigatingCommaArgCS__Group_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__1__Impl"
    // InternalQVTbase.g:16547:1: rule__NavigatingCommaArgCS__Group_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16551:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) ) )
            // InternalQVTbase.g:16552:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) )
            {
            // InternalQVTbase.g:16552:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 ) )
            // InternalQVTbase.g:16553:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1());
            }
            // InternalQVTbase.g:16554:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 )
            // InternalQVTbase.g:16554:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2"
    // InternalQVTbase.g:16564:1: rule__NavigatingCommaArgCS__Group_2_0__2 : rule__NavigatingCommaArgCS__Group_2_0__2__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16568:1: ( rule__NavigatingCommaArgCS__Group_2_0__2__Impl )
            // InternalQVTbase.g:16569:2: rule__NavigatingCommaArgCS__Group_2_0__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0__2__Impl"
    // InternalQVTbase.g:16575:1: rule__NavigatingCommaArgCS__Group_2_0__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16579:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? ) )
            // InternalQVTbase.g:16580:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            {
            // InternalQVTbase.g:16580:1: ( ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )? )
            // InternalQVTbase.g:16581:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2());
            }
            // InternalQVTbase.g:16582:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0 )?
            int alt169=2;
            int LA169_0 = input.LA(1);

            if ( (LA169_0==29) ) {
                alt169=1;
            }
            switch (alt169) {
                case 1 :
                    // InternalQVTbase.g:16582:2: rule__NavigatingCommaArgCS__Group_2_0_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_0_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0"
    // InternalQVTbase.g:16598:1: rule__NavigatingCommaArgCS__Group_2_0_2__0 : rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16602:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1 )
            // InternalQVTbase.g:16603:2: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl rule__NavigatingCommaArgCS__Group_2_0_2__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl"
    // InternalQVTbase.g:16610:1: rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16614:1: ( ( '=' ) )
            // InternalQVTbase.g:16615:1: ( '=' )
            {
            // InternalQVTbase.g:16615:1: ( '=' )
            // InternalQVTbase.g:16616:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1"
    // InternalQVTbase.g:16629:1: rule__NavigatingCommaArgCS__Group_2_0_2__1 : rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16633:1: ( rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl )
            // InternalQVTbase.g:16634:2: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl"
    // InternalQVTbase.g:16640:1: rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16644:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) ) )
            // InternalQVTbase.g:16645:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            {
            // InternalQVTbase.g:16645:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 ) )
            // InternalQVTbase.g:16646:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1());
            }
            // InternalQVTbase.g:16647:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 )
            // InternalQVTbase.g:16647:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_0_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_0_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0"
    // InternalQVTbase.g:16661:1: rule__NavigatingCommaArgCS__Group_2_1__0 : rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16665:1: ( rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1 )
            // InternalQVTbase.g:16666:2: rule__NavigatingCommaArgCS__Group_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingCommaArgCS__Group_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__0__Impl"
    // InternalQVTbase.g:16673:1: rule__NavigatingCommaArgCS__Group_2_1__0__Impl : ( ':' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16677:1: ( ( ':' ) )
            // InternalQVTbase.g:16678:1: ( ':' )
            {
            // InternalQVTbase.g:16678:1: ( ':' )
            // InternalQVTbase.g:16679:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1"
    // InternalQVTbase.g:16692:1: rule__NavigatingCommaArgCS__Group_2_1__1 : rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16696:1: ( rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2 )
            // InternalQVTbase.g:16697:2: rule__NavigatingCommaArgCS__Group_2_1__1__Impl rule__NavigatingCommaArgCS__Group_2_1__2
            {
            pushFollow(FollowSets000.FOLLOW_85);
            rule__NavigatingCommaArgCS__Group_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__1__Impl"
    // InternalQVTbase.g:16704:1: rule__NavigatingCommaArgCS__Group_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16708:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) ) )
            // InternalQVTbase.g:16709:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) )
            {
            // InternalQVTbase.g:16709:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 ) )
            // InternalQVTbase.g:16710:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1());
            }
            // InternalQVTbase.g:16711:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 )
            // InternalQVTbase.g:16711:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2"
    // InternalQVTbase.g:16721:1: rule__NavigatingCommaArgCS__Group_2_1__2 : rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16725:1: ( rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3 )
            // InternalQVTbase.g:16726:2: rule__NavigatingCommaArgCS__Group_2_1__2__Impl rule__NavigatingCommaArgCS__Group_2_1__3
            {
            pushFollow(FollowSets000.FOLLOW_85);
            rule__NavigatingCommaArgCS__Group_2_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__2__Impl"
    // InternalQVTbase.g:16733:1: rule__NavigatingCommaArgCS__Group_2_1__2__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16737:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? ) )
            // InternalQVTbase.g:16738:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? )
            {
            // InternalQVTbase.g:16738:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )? )
            // InternalQVTbase.g:16739:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2());
            }
            // InternalQVTbase.g:16740:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0 )?
            int alt170=2;
            int LA170_0 = input.LA(1);

            if ( (LA170_0==83) ) {
                alt170=1;
            }
            switch (alt170) {
                case 1 :
                    // InternalQVTbase.g:16740:2: rule__NavigatingCommaArgCS__Group_2_1_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3"
    // InternalQVTbase.g:16750:1: rule__NavigatingCommaArgCS__Group_2_1__3 : rule__NavigatingCommaArgCS__Group_2_1__3__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16754:1: ( rule__NavigatingCommaArgCS__Group_2_1__3__Impl )
            // InternalQVTbase.g:16755:2: rule__NavigatingCommaArgCS__Group_2_1__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1__3__Impl"
    // InternalQVTbase.g:16761:1: rule__NavigatingCommaArgCS__Group_2_1__3__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16765:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? ) )
            // InternalQVTbase.g:16766:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? )
            {
            // InternalQVTbase.g:16766:1: ( ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )? )
            // InternalQVTbase.g:16767:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3());
            }
            // InternalQVTbase.g:16768:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0 )?
            int alt171=2;
            int LA171_0 = input.LA(1);

            if ( (LA171_0==29) ) {
                alt171=1;
            }
            switch (alt171) {
                case 1 :
                    // InternalQVTbase.g:16768:2: rule__NavigatingCommaArgCS__Group_2_1_3__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_1_3__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1__3__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0"
    // InternalQVTbase.g:16786:1: rule__NavigatingCommaArgCS__Group_2_1_2__0 : rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16790:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1 )
            // InternalQVTbase.g:16791:2: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl rule__NavigatingCommaArgCS__Group_2_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl"
    // InternalQVTbase.g:16798:1: rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16802:1: ( ( '<-' ) )
            // InternalQVTbase.g:16803:1: ( '<-' )
            {
            // InternalQVTbase.g:16803:1: ( '<-' )
            // InternalQVTbase.g:16804:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1"
    // InternalQVTbase.g:16817:1: rule__NavigatingCommaArgCS__Group_2_1_2__1 : rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16821:1: ( rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl )
            // InternalQVTbase.g:16822:2: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl"
    // InternalQVTbase.g:16828:1: rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16832:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) ) )
            // InternalQVTbase.g:16833:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) )
            {
            // InternalQVTbase.g:16833:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 ) )
            // InternalQVTbase.g:16834:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1());
            }
            // InternalQVTbase.g:16835:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 )
            // InternalQVTbase.g:16835:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0"
    // InternalQVTbase.g:16849:1: rule__NavigatingCommaArgCS__Group_2_1_3__0 : rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16853:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1 )
            // InternalQVTbase.g:16854:2: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl rule__NavigatingCommaArgCS__Group_2_1_3__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_3__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl"
    // InternalQVTbase.g:16861:1: rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl : ( '=' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16865:1: ( ( '=' ) )
            // InternalQVTbase.g:16866:1: ( '=' )
            {
            // InternalQVTbase.g:16866:1: ( '=' )
            // InternalQVTbase.g:16867:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getEqualsSignKeyword_2_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1"
    // InternalQVTbase.g:16880:1: rule__NavigatingCommaArgCS__Group_2_1_3__1 : rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16884:1: ( rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl )
            // InternalQVTbase.g:16885:2: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl"
    // InternalQVTbase.g:16891:1: rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16895:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) ) )
            // InternalQVTbase.g:16896:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) )
            {
            // InternalQVTbase.g:16896:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 ) )
            // InternalQVTbase.g:16897:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1());
            }
            // InternalQVTbase.g:16898:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 )
            // InternalQVTbase.g:16898:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_1_3_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_1_3__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0"
    // InternalQVTbase.g:16912:1: rule__NavigatingCommaArgCS__Group_2_2__0 : rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16916:1: ( rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1 )
            // InternalQVTbase.g:16917:2: rule__NavigatingCommaArgCS__Group_2_2__0__Impl rule__NavigatingCommaArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingCommaArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__0__Impl"
    // InternalQVTbase.g:16924:1: rule__NavigatingCommaArgCS__Group_2_2__0__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16928:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? ) )
            // InternalQVTbase.g:16929:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? )
            {
            // InternalQVTbase.g:16929:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )? )
            // InternalQVTbase.g:16930:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0());
            }
            // InternalQVTbase.g:16931:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0 )?
            int alt172=2;
            int LA172_0 = input.LA(1);

            if ( (LA172_0==61) ) {
                alt172=1;
            }
            switch (alt172) {
                case 1 :
                    // InternalQVTbase.g:16931:2: rule__NavigatingCommaArgCS__Group_2_2_0__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2_0__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1"
    // InternalQVTbase.g:16941:1: rule__NavigatingCommaArgCS__Group_2_2__1 : rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16945:1: ( rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2 )
            // InternalQVTbase.g:16946:2: rule__NavigatingCommaArgCS__Group_2_2__1__Impl rule__NavigatingCommaArgCS__Group_2_2__2
            {
            pushFollow(FollowSets000.FOLLOW_84);
            rule__NavigatingCommaArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__1__Impl"
    // InternalQVTbase.g:16953:1: rule__NavigatingCommaArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16957:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? ) )
            // InternalQVTbase.g:16958:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? )
            {
            // InternalQVTbase.g:16958:1: ( ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )? )
            // InternalQVTbase.g:16959:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1());
            }
            // InternalQVTbase.g:16960:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0 )?
            int alt173=2;
            int LA173_0 = input.LA(1);

            if ( (LA173_0==83) ) {
                alt173=1;
            }
            switch (alt173) {
                case 1 :
                    // InternalQVTbase.g:16960:2: rule__NavigatingCommaArgCS__Group_2_2_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingCommaArgCS__Group_2_2_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2"
    // InternalQVTbase.g:16970:1: rule__NavigatingCommaArgCS__Group_2_2__2 : rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16974:1: ( rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3 )
            // InternalQVTbase.g:16975:2: rule__NavigatingCommaArgCS__Group_2_2__2__Impl rule__NavigatingCommaArgCS__Group_2_2__3
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingCommaArgCS__Group_2_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__2__Impl"
    // InternalQVTbase.g:16982:1: rule__NavigatingCommaArgCS__Group_2_2__2__Impl : ( 'in' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:16986:1: ( ( 'in' ) )
            // InternalQVTbase.g:16987:1: ( 'in' )
            {
            // InternalQVTbase.g:16987:1: ( 'in' )
            // InternalQVTbase.g:16988:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2());
            }
            match(input,89,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getInKeyword_2_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__2__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3"
    // InternalQVTbase.g:17001:1: rule__NavigatingCommaArgCS__Group_2_2__3 : rule__NavigatingCommaArgCS__Group_2_2__3__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17005:1: ( rule__NavigatingCommaArgCS__Group_2_2__3__Impl )
            // InternalQVTbase.g:17006:2: rule__NavigatingCommaArgCS__Group_2_2__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2__3__Impl"
    // InternalQVTbase.g:17012:1: rule__NavigatingCommaArgCS__Group_2_2__3__Impl : ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17016:1: ( ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) ) )
            // InternalQVTbase.g:17017:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) )
            {
            // InternalQVTbase.g:17017:1: ( ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 ) )
            // InternalQVTbase.g:17018:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3());
            }
            // InternalQVTbase.g:17019:1: ( rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 )
            // InternalQVTbase.g:17019:2: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionAssignment_2_2_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2__3__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0"
    // InternalQVTbase.g:17037:1: rule__NavigatingCommaArgCS__Group_2_2_0__0 : rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17041:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1 )
            // InternalQVTbase.g:17042:2: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl rule__NavigatingCommaArgCS__Group_2_2_0__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_0__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl"
    // InternalQVTbase.g:17049:1: rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl : ( ':' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17053:1: ( ( ':' ) )
            // InternalQVTbase.g:17054:1: ( ':' )
            {
            // InternalQVTbase.g:17054:1: ( ':' )
            // InternalQVTbase.g:17055:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getColonKeyword_2_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1"
    // InternalQVTbase.g:17068:1: rule__NavigatingCommaArgCS__Group_2_2_0__1 : rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17072:1: ( rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl )
            // InternalQVTbase.g:17073:2: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl"
    // InternalQVTbase.g:17079:1: rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17083:1: ( ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) ) )
            // InternalQVTbase.g:17084:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) )
            {
            // InternalQVTbase.g:17084:1: ( ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 ) )
            // InternalQVTbase.g:17085:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1());
            }
            // InternalQVTbase.g:17086:1: ( rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 )
            // InternalQVTbase.g:17086:2: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeAssignment_2_2_0_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_0__1__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0"
    // InternalQVTbase.g:17100:1: rule__NavigatingCommaArgCS__Group_2_2_1__0 : rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17104:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1 )
            // InternalQVTbase.g:17105:2: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl rule__NavigatingCommaArgCS__Group_2_2_1__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl"
    // InternalQVTbase.g:17112:1: rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl : ( '<-' ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17116:1: ( ( '<-' ) )
            // InternalQVTbase.g:17117:1: ( '<-' )
            {
            // InternalQVTbase.g:17117:1: ( '<-' )
            // InternalQVTbase.g:17118:1: '<-'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0());
            }
            match(input,83,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getLessThanSignHyphenMinusKeyword_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__0__Impl"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1"
    // InternalQVTbase.g:17131:1: rule__NavigatingCommaArgCS__Group_2_2_1__1 : rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17135:1: ( rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl )
            // InternalQVTbase.g:17136:2: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__1"


    // $ANTLR start "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl"
    // InternalQVTbase.g:17142:1: rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl : ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) ;
    public final void rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17146:1: ( ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) ) )
            // InternalQVTbase.g:17147:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) )
            {
            // InternalQVTbase.g:17147:1: ( ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 ) )
            // InternalQVTbase.g:17148:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1());
            }
            // InternalQVTbase.g:17149:1: ( rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 )
            // InternalQVTbase.g:17149:2: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorAssignment_2_2_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__Group_2_2_1__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__0"
    // InternalQVTbase.g:17163:1: rule__NavigatingSemiArgCS__Group__0 : rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 ;
    public final void rule__NavigatingSemiArgCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17167:1: ( rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1 )
            // InternalQVTbase.g:17168:2: rule__NavigatingSemiArgCS__Group__0__Impl rule__NavigatingSemiArgCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingSemiArgCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__0__Impl"
    // InternalQVTbase.g:17175:1: rule__NavigatingSemiArgCS__Group__0__Impl : ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17179:1: ( ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) ) )
            // InternalQVTbase.g:17180:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            {
            // InternalQVTbase.g:17180:1: ( ( rule__NavigatingSemiArgCS__PrefixAssignment_0 ) )
            // InternalQVTbase.g:17181:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0());
            }
            // InternalQVTbase.g:17182:1: ( rule__NavigatingSemiArgCS__PrefixAssignment_0 )
            // InternalQVTbase.g:17182:2: rule__NavigatingSemiArgCS__PrefixAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__PrefixAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__1"
    // InternalQVTbase.g:17192:1: rule__NavigatingSemiArgCS__Group__1 : rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 ;
    public final void rule__NavigatingSemiArgCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17196:1: ( rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2 )
            // InternalQVTbase.g:17197:2: rule__NavigatingSemiArgCS__Group__1__Impl rule__NavigatingSemiArgCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__NavigatingSemiArgCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__1__Impl"
    // InternalQVTbase.g:17204:1: rule__NavigatingSemiArgCS__Group__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17208:1: ( ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) ) )
            // InternalQVTbase.g:17209:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            {
            // InternalQVTbase.g:17209:1: ( ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 ) )
            // InternalQVTbase.g:17210:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1());
            }
            // InternalQVTbase.g:17211:1: ( rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 )
            // InternalQVTbase.g:17211:2: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__2"
    // InternalQVTbase.g:17221:1: rule__NavigatingSemiArgCS__Group__2 : rule__NavigatingSemiArgCS__Group__2__Impl ;
    public final void rule__NavigatingSemiArgCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17225:1: ( rule__NavigatingSemiArgCS__Group__2__Impl )
            // InternalQVTbase.g:17226:2: rule__NavigatingSemiArgCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__2"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group__2__Impl"
    // InternalQVTbase.g:17232:1: rule__NavigatingSemiArgCS__Group__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) ;
    public final void rule__NavigatingSemiArgCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17236:1: ( ( ( rule__NavigatingSemiArgCS__Group_2__0 )? ) )
            // InternalQVTbase.g:17237:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:17237:1: ( ( rule__NavigatingSemiArgCS__Group_2__0 )? )
            // InternalQVTbase.g:17238:1: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:17239:1: ( rule__NavigatingSemiArgCS__Group_2__0 )?
            int alt174=2;
            int LA174_0 = input.LA(1);

            if ( (LA174_0==61) ) {
                alt174=1;
            }
            switch (alt174) {
                case 1 :
                    // InternalQVTbase.g:17239:2: rule__NavigatingSemiArgCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingSemiArgCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group__2__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0"
    // InternalQVTbase.g:17255:1: rule__NavigatingSemiArgCS__Group_2__0 : rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 ;
    public final void rule__NavigatingSemiArgCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17259:1: ( rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1 )
            // InternalQVTbase.g:17260:2: rule__NavigatingSemiArgCS__Group_2__0__Impl rule__NavigatingSemiArgCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__NavigatingSemiArgCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__0__Impl"
    // InternalQVTbase.g:17267:1: rule__NavigatingSemiArgCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17271:1: ( ( ':' ) )
            // InternalQVTbase.g:17272:1: ( ':' )
            {
            // InternalQVTbase.g:17272:1: ( ':' )
            // InternalQVTbase.g:17273:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1"
    // InternalQVTbase.g:17286:1: rule__NavigatingSemiArgCS__Group_2__1 : rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 ;
    public final void rule__NavigatingSemiArgCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17290:1: ( rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2 )
            // InternalQVTbase.g:17291:2: rule__NavigatingSemiArgCS__Group_2__1__Impl rule__NavigatingSemiArgCS__Group_2__2
            {
            pushFollow(FollowSets000.FOLLOW_64);
            rule__NavigatingSemiArgCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__1__Impl"
    // InternalQVTbase.g:17298:1: rule__NavigatingSemiArgCS__Group_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17302:1: ( ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalQVTbase.g:17303:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalQVTbase.g:17303:1: ( ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 ) )
            // InternalQVTbase.g:17304:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalQVTbase.g:17305:1: ( rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 )
            // InternalQVTbase.g:17305:2: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__1__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2"
    // InternalQVTbase.g:17315:1: rule__NavigatingSemiArgCS__Group_2__2 : rule__NavigatingSemiArgCS__Group_2__2__Impl ;
    public final void rule__NavigatingSemiArgCS__Group_2__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17319:1: ( rule__NavigatingSemiArgCS__Group_2__2__Impl )
            // InternalQVTbase.g:17320:2: rule__NavigatingSemiArgCS__Group_2__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__2"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2__2__Impl"
    // InternalQVTbase.g:17326:1: rule__NavigatingSemiArgCS__Group_2__2__Impl : ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) ;
    public final void rule__NavigatingSemiArgCS__Group_2__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17330:1: ( ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? ) )
            // InternalQVTbase.g:17331:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            {
            // InternalQVTbase.g:17331:1: ( ( rule__NavigatingSemiArgCS__Group_2_2__0 )? )
            // InternalQVTbase.g:17332:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2());
            }
            // InternalQVTbase.g:17333:1: ( rule__NavigatingSemiArgCS__Group_2_2__0 )?
            int alt175=2;
            int LA175_0 = input.LA(1);

            if ( (LA175_0==29) ) {
                alt175=1;
            }
            switch (alt175) {
                case 1 :
                    // InternalQVTbase.g:17333:2: rule__NavigatingSemiArgCS__Group_2_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__NavigatingSemiArgCS__Group_2_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getGroup_2_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2__2__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0"
    // InternalQVTbase.g:17349:1: rule__NavigatingSemiArgCS__Group_2_2__0 : rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17353:1: ( rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1 )
            // InternalQVTbase.g:17354:2: rule__NavigatingSemiArgCS__Group_2_2__0__Impl rule__NavigatingSemiArgCS__Group_2_2__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NavigatingSemiArgCS__Group_2_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__0__Impl"
    // InternalQVTbase.g:17361:1: rule__NavigatingSemiArgCS__Group_2_2__0__Impl : ( '=' ) ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17365:1: ( ( '=' ) )
            // InternalQVTbase.g:17366:1: ( '=' )
            {
            // InternalQVTbase.g:17366:1: ( '=' )
            // InternalQVTbase.g:17367:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getEqualsSignKeyword_2_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__0__Impl"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1"
    // InternalQVTbase.g:17380:1: rule__NavigatingSemiArgCS__Group_2_2__1 : rule__NavigatingSemiArgCS__Group_2_2__1__Impl ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17384:1: ( rule__NavigatingSemiArgCS__Group_2_2__1__Impl )
            // InternalQVTbase.g:17385:2: rule__NavigatingSemiArgCS__Group_2_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__Group_2_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1"


    // $ANTLR start "rule__NavigatingSemiArgCS__Group_2_2__1__Impl"
    // InternalQVTbase.g:17391:1: rule__NavigatingSemiArgCS__Group_2_2__1__Impl : ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) ;
    public final void rule__NavigatingSemiArgCS__Group_2_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17395:1: ( ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) ) )
            // InternalQVTbase.g:17396:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            {
            // InternalQVTbase.g:17396:1: ( ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 ) )
            // InternalQVTbase.g:17397:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }
            // InternalQVTbase.g:17398:1: ( rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 )
            // InternalQVTbase.g:17398:2: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionAssignment_2_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__Group_2_2__1__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__0"
    // InternalQVTbase.g:17412:1: rule__CoIteratorVariableCS__Group__0 : rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 ;
    public final void rule__CoIteratorVariableCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17416:1: ( rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1 )
            // InternalQVTbase.g:17417:2: rule__CoIteratorVariableCS__Group__0__Impl rule__CoIteratorVariableCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_57);
            rule__CoIteratorVariableCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__0"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__0__Impl"
    // InternalQVTbase.g:17424:1: rule__CoIteratorVariableCS__Group__0__Impl : ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) ;
    public final void rule__CoIteratorVariableCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17428:1: ( ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:17429:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:17429:1: ( ( rule__CoIteratorVariableCS__NameAssignment_0 ) )
            // InternalQVTbase.g:17430:1: ( rule__CoIteratorVariableCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:17431:1: ( rule__CoIteratorVariableCS__NameAssignment_0 )
            // InternalQVTbase.g:17431:2: rule__CoIteratorVariableCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__0__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__1"
    // InternalQVTbase.g:17441:1: rule__CoIteratorVariableCS__Group__1 : rule__CoIteratorVariableCS__Group__1__Impl ;
    public final void rule__CoIteratorVariableCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17445:1: ( rule__CoIteratorVariableCS__Group__1__Impl )
            // InternalQVTbase.g:17446:2: rule__CoIteratorVariableCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__1"


    // $ANTLR start "rule__CoIteratorVariableCS__Group__1__Impl"
    // InternalQVTbase.g:17452:1: rule__CoIteratorVariableCS__Group__1__Impl : ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) ;
    public final void rule__CoIteratorVariableCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17456:1: ( ( ( rule__CoIteratorVariableCS__Group_1__0 )? ) )
            // InternalQVTbase.g:17457:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:17457:1: ( ( rule__CoIteratorVariableCS__Group_1__0 )? )
            // InternalQVTbase.g:17458:1: ( rule__CoIteratorVariableCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:17459:1: ( rule__CoIteratorVariableCS__Group_1__0 )?
            int alt176=2;
            int LA176_0 = input.LA(1);

            if ( (LA176_0==61) ) {
                alt176=1;
            }
            switch (alt176) {
                case 1 :
                    // InternalQVTbase.g:17459:2: rule__CoIteratorVariableCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__CoIteratorVariableCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group__1__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0"
    // InternalQVTbase.g:17473:1: rule__CoIteratorVariableCS__Group_1__0 : rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 ;
    public final void rule__CoIteratorVariableCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17477:1: ( rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1 )
            // InternalQVTbase.g:17478:2: rule__CoIteratorVariableCS__Group_1__0__Impl rule__CoIteratorVariableCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__CoIteratorVariableCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__0__Impl"
    // InternalQVTbase.g:17485:1: rule__CoIteratorVariableCS__Group_1__0__Impl : ( ':' ) ;
    public final void rule__CoIteratorVariableCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17489:1: ( ( ':' ) )
            // InternalQVTbase.g:17490:1: ( ':' )
            {
            // InternalQVTbase.g:17490:1: ( ':' )
            // InternalQVTbase.g:17491:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__0__Impl"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1"
    // InternalQVTbase.g:17504:1: rule__CoIteratorVariableCS__Group_1__1 : rule__CoIteratorVariableCS__Group_1__1__Impl ;
    public final void rule__CoIteratorVariableCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17508:1: ( rule__CoIteratorVariableCS__Group_1__1__Impl )
            // InternalQVTbase.g:17509:2: rule__CoIteratorVariableCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__1"


    // $ANTLR start "rule__CoIteratorVariableCS__Group_1__1__Impl"
    // InternalQVTbase.g:17515:1: rule__CoIteratorVariableCS__Group_1__1__Impl : ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) ;
    public final void rule__CoIteratorVariableCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17519:1: ( ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) ) )
            // InternalQVTbase.g:17520:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) )
            {
            // InternalQVTbase.g:17520:1: ( ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 ) )
            // InternalQVTbase.g:17521:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1());
            }
            // InternalQVTbase.g:17522:1: ( rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 )
            // InternalQVTbase.g:17522:2: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__Group_1__1__Impl"


    // $ANTLR start "rule__IfExpCS__Group__0"
    // InternalQVTbase.g:17536:1: rule__IfExpCS__Group__0 : rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 ;
    public final void rule__IfExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17540:1: ( rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1 )
            // InternalQVTbase.g:17541:2: rule__IfExpCS__Group__0__Impl rule__IfExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_60);
            rule__IfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__0"


    // $ANTLR start "rule__IfExpCS__Group__0__Impl"
    // InternalQVTbase.g:17548:1: rule__IfExpCS__Group__0__Impl : ( 'if' ) ;
    public final void rule__IfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17552:1: ( ( 'if' ) )
            // InternalQVTbase.g:17553:1: ( 'if' )
            {
            // InternalQVTbase.g:17553:1: ( 'if' )
            // InternalQVTbase.g:17554:1: 'if'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getIfKeyword_0());
            }
            match(input,90,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getIfKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__0__Impl"


    // $ANTLR start "rule__IfExpCS__Group__1"
    // InternalQVTbase.g:17567:1: rule__IfExpCS__Group__1 : rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 ;
    public final void rule__IfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17571:1: ( rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2 )
            // InternalQVTbase.g:17572:2: rule__IfExpCS__Group__1__Impl rule__IfExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_86);
            rule__IfExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__1"


    // $ANTLR start "rule__IfExpCS__Group__1__Impl"
    // InternalQVTbase.g:17579:1: rule__IfExpCS__Group__1__Impl : ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__IfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17583:1: ( ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalQVTbase.g:17584:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalQVTbase.g:17584:1: ( ( rule__IfExpCS__OwnedConditionAssignment_1 ) )
            // InternalQVTbase.g:17585:1: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1());
            }
            // InternalQVTbase.g:17586:1: ( rule__IfExpCS__OwnedConditionAssignment_1 )
            // InternalQVTbase.g:17586:2: rule__IfExpCS__OwnedConditionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedConditionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedConditionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__1__Impl"


    // $ANTLR start "rule__IfExpCS__Group__2"
    // InternalQVTbase.g:17596:1: rule__IfExpCS__Group__2 : rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 ;
    public final void rule__IfExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17600:1: ( rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3 )
            // InternalQVTbase.g:17601:2: rule__IfExpCS__Group__2__Impl rule__IfExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__IfExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__2"


    // $ANTLR start "rule__IfExpCS__Group__2__Impl"
    // InternalQVTbase.g:17608:1: rule__IfExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__IfExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17612:1: ( ( 'then' ) )
            // InternalQVTbase.g:17613:1: ( 'then' )
            {
            // InternalQVTbase.g:17613:1: ( 'then' )
            // InternalQVTbase.g:17614:1: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getThenKeyword_2());
            }
            match(input,91,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getThenKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__2__Impl"


    // $ANTLR start "rule__IfExpCS__Group__3"
    // InternalQVTbase.g:17627:1: rule__IfExpCS__Group__3 : rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 ;
    public final void rule__IfExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17631:1: ( rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4 )
            // InternalQVTbase.g:17632:2: rule__IfExpCS__Group__3__Impl rule__IfExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_87);
            rule__IfExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__3"


    // $ANTLR start "rule__IfExpCS__Group__3__Impl"
    // InternalQVTbase.g:17639:1: rule__IfExpCS__Group__3__Impl : ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__IfExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17643:1: ( ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalQVTbase.g:17644:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalQVTbase.g:17644:1: ( ( rule__IfExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalQVTbase.g:17645:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3());
            }
            // InternalQVTbase.g:17646:1: ( rule__IfExpCS__OwnedThenExpressionAssignment_3 )
            // InternalQVTbase.g:17646:2: rule__IfExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedThenExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__3__Impl"


    // $ANTLR start "rule__IfExpCS__Group__4"
    // InternalQVTbase.g:17656:1: rule__IfExpCS__Group__4 : rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 ;
    public final void rule__IfExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17660:1: ( rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5 )
            // InternalQVTbase.g:17661:2: rule__IfExpCS__Group__4__Impl rule__IfExpCS__Group__5
            {
            pushFollow(FollowSets000.FOLLOW_87);
            rule__IfExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__5();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__4"


    // $ANTLR start "rule__IfExpCS__Group__4__Impl"
    // InternalQVTbase.g:17668:1: rule__IfExpCS__Group__4__Impl : ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) ;
    public final void rule__IfExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17672:1: ( ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* ) )
            // InternalQVTbase.g:17673:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            {
            // InternalQVTbase.g:17673:1: ( ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )* )
            // InternalQVTbase.g:17674:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4());
            }
            // InternalQVTbase.g:17675:1: ( rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 )*
            loop177:
            do {
                int alt177=2;
                int LA177_0 = input.LA(1);

                if ( (LA177_0==94) ) {
                    alt177=1;
                }


                switch (alt177) {
            	case 1 :
            	    // InternalQVTbase.g:17675:2: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4
            	    {
            	    pushFollow(FollowSets000.FOLLOW_88);
            	    rule__IfExpCS__OwnedIfThenExpressionsAssignment_4();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop177;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__4__Impl"


    // $ANTLR start "rule__IfExpCS__Group__5"
    // InternalQVTbase.g:17685:1: rule__IfExpCS__Group__5 : rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 ;
    public final void rule__IfExpCS__Group__5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17689:1: ( rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6 )
            // InternalQVTbase.g:17690:2: rule__IfExpCS__Group__5__Impl rule__IfExpCS__Group__6
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__IfExpCS__Group__5__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__6();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__5"


    // $ANTLR start "rule__IfExpCS__Group__5__Impl"
    // InternalQVTbase.g:17697:1: rule__IfExpCS__Group__5__Impl : ( 'else' ) ;
    public final void rule__IfExpCS__Group__5__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17701:1: ( ( 'else' ) )
            // InternalQVTbase.g:17702:1: ( 'else' )
            {
            // InternalQVTbase.g:17702:1: ( 'else' )
            // InternalQVTbase.g:17703:1: 'else'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getElseKeyword_5());
            }
            match(input,92,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getElseKeyword_5());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__5__Impl"


    // $ANTLR start "rule__IfExpCS__Group__6"
    // InternalQVTbase.g:17716:1: rule__IfExpCS__Group__6 : rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 ;
    public final void rule__IfExpCS__Group__6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17720:1: ( rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7 )
            // InternalQVTbase.g:17721:2: rule__IfExpCS__Group__6__Impl rule__IfExpCS__Group__7
            {
            pushFollow(FollowSets000.FOLLOW_89);
            rule__IfExpCS__Group__6__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__7();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__6"


    // $ANTLR start "rule__IfExpCS__Group__6__Impl"
    // InternalQVTbase.g:17728:1: rule__IfExpCS__Group__6__Impl : ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) ;
    public final void rule__IfExpCS__Group__6__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17732:1: ( ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) ) )
            // InternalQVTbase.g:17733:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            {
            // InternalQVTbase.g:17733:1: ( ( rule__IfExpCS__OwnedElseExpressionAssignment_6 ) )
            // InternalQVTbase.g:17734:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6());
            }
            // InternalQVTbase.g:17735:1: ( rule__IfExpCS__OwnedElseExpressionAssignment_6 )
            // InternalQVTbase.g:17735:2: rule__IfExpCS__OwnedElseExpressionAssignment_6
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedElseExpressionAssignment_6();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionAssignment_6());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__6__Impl"


    // $ANTLR start "rule__IfExpCS__Group__7"
    // InternalQVTbase.g:17745:1: rule__IfExpCS__Group__7 : rule__IfExpCS__Group__7__Impl ;
    public final void rule__IfExpCS__Group__7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17749:1: ( rule__IfExpCS__Group__7__Impl )
            // InternalQVTbase.g:17750:2: rule__IfExpCS__Group__7__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__Group__7__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__7"


    // $ANTLR start "rule__IfExpCS__Group__7__Impl"
    // InternalQVTbase.g:17756:1: rule__IfExpCS__Group__7__Impl : ( 'endif' ) ;
    public final void rule__IfExpCS__Group__7__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17760:1: ( ( 'endif' ) )
            // InternalQVTbase.g:17761:1: ( 'endif' )
            {
            // InternalQVTbase.g:17761:1: ( 'endif' )
            // InternalQVTbase.g:17762:1: 'endif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getEndifKeyword_7());
            }
            match(input,93,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getEndifKeyword_7());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__Group__7__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__0"
    // InternalQVTbase.g:17791:1: rule__ElseIfThenExpCS__Group__0 : rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 ;
    public final void rule__ElseIfThenExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17795:1: ( rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1 )
            // InternalQVTbase.g:17796:2: rule__ElseIfThenExpCS__Group__0__Impl rule__ElseIfThenExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__ElseIfThenExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__0"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__0__Impl"
    // InternalQVTbase.g:17803:1: rule__ElseIfThenExpCS__Group__0__Impl : ( 'elseif' ) ;
    public final void rule__ElseIfThenExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17807:1: ( ( 'elseif' ) )
            // InternalQVTbase.g:17808:1: ( 'elseif' )
            {
            // InternalQVTbase.g:17808:1: ( 'elseif' )
            // InternalQVTbase.g:17809:1: 'elseif'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0());
            }
            match(input,94,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getElseifKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__0__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__1"
    // InternalQVTbase.g:17822:1: rule__ElseIfThenExpCS__Group__1 : rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 ;
    public final void rule__ElseIfThenExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17826:1: ( rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2 )
            // InternalQVTbase.g:17827:2: rule__ElseIfThenExpCS__Group__1__Impl rule__ElseIfThenExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_86);
            rule__ElseIfThenExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__1"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__1__Impl"
    // InternalQVTbase.g:17834:1: rule__ElseIfThenExpCS__Group__1__Impl : ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17838:1: ( ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) ) )
            // InternalQVTbase.g:17839:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            {
            // InternalQVTbase.g:17839:1: ( ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 ) )
            // InternalQVTbase.g:17840:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1());
            }
            // InternalQVTbase.g:17841:1: ( rule__ElseIfThenExpCS__OwnedConditionAssignment_1 )
            // InternalQVTbase.g:17841:2: rule__ElseIfThenExpCS__OwnedConditionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__OwnedConditionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__1__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__2"
    // InternalQVTbase.g:17851:1: rule__ElseIfThenExpCS__Group__2 : rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 ;
    public final void rule__ElseIfThenExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17855:1: ( rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3 )
            // InternalQVTbase.g:17856:2: rule__ElseIfThenExpCS__Group__2__Impl rule__ElseIfThenExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__ElseIfThenExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__2"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__2__Impl"
    // InternalQVTbase.g:17863:1: rule__ElseIfThenExpCS__Group__2__Impl : ( 'then' ) ;
    public final void rule__ElseIfThenExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17867:1: ( ( 'then' ) )
            // InternalQVTbase.g:17868:1: ( 'then' )
            {
            // InternalQVTbase.g:17868:1: ( 'then' )
            // InternalQVTbase.g:17869:1: 'then'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2());
            }
            match(input,91,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getThenKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__2__Impl"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__3"
    // InternalQVTbase.g:17882:1: rule__ElseIfThenExpCS__Group__3 : rule__ElseIfThenExpCS__Group__3__Impl ;
    public final void rule__ElseIfThenExpCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17886:1: ( rule__ElseIfThenExpCS__Group__3__Impl )
            // InternalQVTbase.g:17887:2: rule__ElseIfThenExpCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__3"


    // $ANTLR start "rule__ElseIfThenExpCS__Group__3__Impl"
    // InternalQVTbase.g:17893:1: rule__ElseIfThenExpCS__Group__3__Impl : ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) ;
    public final void rule__ElseIfThenExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17897:1: ( ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) ) )
            // InternalQVTbase.g:17898:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            {
            // InternalQVTbase.g:17898:1: ( ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 ) )
            // InternalQVTbase.g:17899:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3());
            }
            // InternalQVTbase.g:17900:1: ( rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 )
            // InternalQVTbase.g:17900:2: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionAssignment_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__Group__3__Impl"


    // $ANTLR start "rule__LetExpCS__Group__0"
    // InternalQVTbase.g:17918: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 {
            // InternalQVTbase.g:17922:1: ( rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1 )
            // InternalQVTbase.g:17923:2: rule__LetExpCS__Group__0__Impl rule__LetExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__LetExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__0"


    // $ANTLR start "rule__LetExpCS__Group__0__Impl"
    // InternalQVTbase.g:17930:1: rule__LetExpCS__Group__0__Impl : ( 'let' ) ;
    public final void rule__LetExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17934:1: ( ( 'let' ) )
            // InternalQVTbase.g:17935:1: ( 'let' )
            {
            // InternalQVTbase.g:17935:1: ( 'let' )
            // InternalQVTbase.g:17936:1: 'let'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getLetKeyword_0());
            }
            match(input,95,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getLetKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__0__Impl"


    // $ANTLR start "rule__LetExpCS__Group__1"
    // InternalQVTbase.g:17949: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 {
            // InternalQVTbase.g:17953:1: ( rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2 )
            // InternalQVTbase.g:17954:2: rule__LetExpCS__Group__1__Impl rule__LetExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_90);
            rule__LetExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__1"


    // $ANTLR start "rule__LetExpCS__Group__1__Impl"
    // InternalQVTbase.g:17961:1: rule__LetExpCS__Group__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) ;
    public final void rule__LetExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:17965:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) ) )
            // InternalQVTbase.g:17966:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            {
            // InternalQVTbase.g:17966:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_1 ) )
            // InternalQVTbase.g:17967:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1());
            }
            // InternalQVTbase.g:17968:1: ( rule__LetExpCS__OwnedVariablesAssignment_1 )
            // InternalQVTbase.g:17968:2: rule__LetExpCS__OwnedVariablesAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedVariablesAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__1__Impl"


    // $ANTLR start "rule__LetExpCS__Group__2"
    // InternalQVTbase.g:17978: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 {
            // InternalQVTbase.g:17982:1: ( rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3 )
            // InternalQVTbase.g:17983:2: rule__LetExpCS__Group__2__Impl rule__LetExpCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_90);
            rule__LetExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__2"


    // $ANTLR start "rule__LetExpCS__Group__2__Impl"
    // InternalQVTbase.g:17990: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 {
            // InternalQVTbase.g:17994:1: ( ( ( rule__LetExpCS__Group_2__0 )* ) )
            // InternalQVTbase.g:17995:1: ( ( rule__LetExpCS__Group_2__0 )* )
            {
            // InternalQVTbase.g:17995:1: ( ( rule__LetExpCS__Group_2__0 )* )
            // InternalQVTbase.g:17996:1: ( rule__LetExpCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:17997:1: ( rule__LetExpCS__Group_2__0 )*
            loop178:
            do {
                int alt178=2;
                int LA178_0 = input.LA(1);

                if ( (LA178_0==64) ) {
                    alt178=1;
                }


                switch (alt178) {
            	case 1 :
            	    // InternalQVTbase.g:17997:2: rule__LetExpCS__Group_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__LetExpCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop178;
                }
            } 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"
    // InternalQVTbase.g:18007: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 {
            // InternalQVTbase.g:18011:1: ( rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4 )
            // InternalQVTbase.g:18012:2: rule__LetExpCS__Group__3__Impl rule__LetExpCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__LetExpCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__3"


    // $ANTLR start "rule__LetExpCS__Group__3__Impl"
    // InternalQVTbase.g:18019:1: rule__LetExpCS__Group__3__Impl : ( 'in' ) ;
    public final void rule__LetExpCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18023:1: ( ( 'in' ) )
            // InternalQVTbase.g:18024:1: ( 'in' )
            {
            // InternalQVTbase.g:18024:1: ( 'in' )
            // InternalQVTbase.g:18025:1: 'in'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getInKeyword_3());
            }
            match(input,89,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getInKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__3__Impl"


    // $ANTLR start "rule__LetExpCS__Group__4"
    // InternalQVTbase.g:18038:1: rule__LetExpCS__Group__4 : rule__LetExpCS__Group__4__Impl ;
    public final void rule__LetExpCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18042:1: ( rule__LetExpCS__Group__4__Impl )
            // InternalQVTbase.g:18043:2: rule__LetExpCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__4"


    // $ANTLR start "rule__LetExpCS__Group__4__Impl"
    // InternalQVTbase.g:18049:1: rule__LetExpCS__Group__4__Impl : ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) ;
    public final void rule__LetExpCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18053:1: ( ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) ) )
            // InternalQVTbase.g:18054:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            {
            // InternalQVTbase.g:18054:1: ( ( rule__LetExpCS__OwnedInExpressionAssignment_4 ) )
            // InternalQVTbase.g:18055:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4());
            }
            // InternalQVTbase.g:18056:1: ( rule__LetExpCS__OwnedInExpressionAssignment_4 )
            // InternalQVTbase.g:18056:2: rule__LetExpCS__OwnedInExpressionAssignment_4
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedInExpressionAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group__4__Impl"


    // $ANTLR start "rule__LetExpCS__Group_2__0"
    // InternalQVTbase.g:18076: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 {
            // InternalQVTbase.g:18080:1: ( rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1 )
            // InternalQVTbase.g:18081:2: rule__LetExpCS__Group_2__0__Impl rule__LetExpCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__LetExpCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__0"


    // $ANTLR start "rule__LetExpCS__Group_2__0__Impl"
    // InternalQVTbase.g:18088:1: rule__LetExpCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__LetExpCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18092:1: ( ( ',' ) )
            // InternalQVTbase.g:18093:1: ( ',' )
            {
            // InternalQVTbase.g:18093:1: ( ',' )
            // InternalQVTbase.g:18094:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getCommaKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__0__Impl"


    // $ANTLR start "rule__LetExpCS__Group_2__1"
    // InternalQVTbase.g:18107: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 {
            // InternalQVTbase.g:18111:1: ( rule__LetExpCS__Group_2__1__Impl )
            // InternalQVTbase.g:18112:2: rule__LetExpCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__1"


    // $ANTLR start "rule__LetExpCS__Group_2__1__Impl"
    // InternalQVTbase.g:18118:1: rule__LetExpCS__Group_2__1__Impl : ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) ;
    public final void rule__LetExpCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18122:1: ( ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) ) )
            // InternalQVTbase.g:18123:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            {
            // InternalQVTbase.g:18123:1: ( ( rule__LetExpCS__OwnedVariablesAssignment_2_1 ) )
            // InternalQVTbase.g:18124:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1());
            }
            // InternalQVTbase.g:18125:1: ( rule__LetExpCS__OwnedVariablesAssignment_2_1 )
            // InternalQVTbase.g:18125:2: rule__LetExpCS__OwnedVariablesAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetExpCS__OwnedVariablesAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__Group_2__1__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__0"
    // InternalQVTbase.g:18139:1: rule__LetVariableCS__Group__0 : rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 ;
    public final void rule__LetVariableCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18143:1: ( rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1 )
            // InternalQVTbase.g:18144:2: rule__LetVariableCS__Group__0__Impl rule__LetVariableCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_91);
            rule__LetVariableCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__0"


    // $ANTLR start "rule__LetVariableCS__Group__0__Impl"
    // InternalQVTbase.g:18151:1: rule__LetVariableCS__Group__0__Impl : ( ( rule__LetVariableCS__NameAssignment_0 ) ) ;
    public final void rule__LetVariableCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18155:1: ( ( ( rule__LetVariableCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:18156:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:18156:1: ( ( rule__LetVariableCS__NameAssignment_0 ) )
            // InternalQVTbase.g:18157:1: ( rule__LetVariableCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:18158:1: ( rule__LetVariableCS__NameAssignment_0 )
            // InternalQVTbase.g:18158:2: rule__LetVariableCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__0__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__1"
    // InternalQVTbase.g:18168:1: rule__LetVariableCS__Group__1 : rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 ;
    public final void rule__LetVariableCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18172:1: ( rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2 )
            // InternalQVTbase.g:18173:2: rule__LetVariableCS__Group__1__Impl rule__LetVariableCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_91);
            rule__LetVariableCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__1"


    // $ANTLR start "rule__LetVariableCS__Group__1__Impl"
    // InternalQVTbase.g:18180:1: rule__LetVariableCS__Group__1__Impl : ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) ;
    public final void rule__LetVariableCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18184:1: ( ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? ) )
            // InternalQVTbase.g:18185:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            {
            // InternalQVTbase.g:18185:1: ( ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )? )
            // InternalQVTbase.g:18186:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1());
            }
            // InternalQVTbase.g:18187:1: ( rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 )?
            int alt179=2;
            int LA179_0 = input.LA(1);

            if ( (LA179_0==71) ) {
                alt179=1;
            }
            switch (alt179) {
                case 1 :
                    // InternalQVTbase.g:18187:2: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__1__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__2"
    // InternalQVTbase.g:18197:1: rule__LetVariableCS__Group__2 : rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 ;
    public final void rule__LetVariableCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18201:1: ( rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3 )
            // InternalQVTbase.g:18202:2: rule__LetVariableCS__Group__2__Impl rule__LetVariableCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_91);
            rule__LetVariableCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__2"


    // $ANTLR start "rule__LetVariableCS__Group__2__Impl"
    // InternalQVTbase.g:18209:1: rule__LetVariableCS__Group__2__Impl : ( ( rule__LetVariableCS__Group_2__0 )? ) ;
    public final void rule__LetVariableCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18213:1: ( ( ( rule__LetVariableCS__Group_2__0 )? ) )
            // InternalQVTbase.g:18214:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:18214:1: ( ( rule__LetVariableCS__Group_2__0 )? )
            // InternalQVTbase.g:18215:1: ( rule__LetVariableCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:18216:1: ( rule__LetVariableCS__Group_2__0 )?
            int alt180=2;
            int LA180_0 = input.LA(1);

            if ( (LA180_0==61) ) {
                alt180=1;
            }
            switch (alt180) {
                case 1 :
                    // InternalQVTbase.g:18216:2: rule__LetVariableCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__LetVariableCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__2__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__3"
    // InternalQVTbase.g:18226:1: rule__LetVariableCS__Group__3 : rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 ;
    public final void rule__LetVariableCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18230:1: ( rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4 )
            // InternalQVTbase.g:18231:2: rule__LetVariableCS__Group__3__Impl rule__LetVariableCS__Group__4
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__LetVariableCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__4();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__3"


    // $ANTLR start "rule__LetVariableCS__Group__3__Impl"
    // InternalQVTbase.g:18238:1: rule__LetVariableCS__Group__3__Impl : ( '=' ) ;
    public final void rule__LetVariableCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18242:1: ( ( '=' ) )
            // InternalQVTbase.g:18243:1: ( '=' )
            {
            // InternalQVTbase.g:18243:1: ( '=' )
            // InternalQVTbase.g:18244:1: '='
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3());
            }
            match(input,29,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getEqualsSignKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__3__Impl"


    // $ANTLR start "rule__LetVariableCS__Group__4"
    // InternalQVTbase.g:18257:1: rule__LetVariableCS__Group__4 : rule__LetVariableCS__Group__4__Impl ;
    public final void rule__LetVariableCS__Group__4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18261:1: ( rule__LetVariableCS__Group__4__Impl )
            // InternalQVTbase.g:18262:2: rule__LetVariableCS__Group__4__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group__4__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__4"


    // $ANTLR start "rule__LetVariableCS__Group__4__Impl"
    // InternalQVTbase.g:18268:1: rule__LetVariableCS__Group__4__Impl : ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) ;
    public final void rule__LetVariableCS__Group__4__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18272:1: ( ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) ) )
            // InternalQVTbase.g:18273:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            {
            // InternalQVTbase.g:18273:1: ( ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 ) )
            // InternalQVTbase.g:18274:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4());
            }
            // InternalQVTbase.g:18275:1: ( rule__LetVariableCS__OwnedInitExpressionAssignment_4 )
            // InternalQVTbase.g:18275:2: rule__LetVariableCS__OwnedInitExpressionAssignment_4
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__OwnedInitExpressionAssignment_4();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionAssignment_4());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group__4__Impl"


    // $ANTLR start "rule__LetVariableCS__Group_2__0"
    // InternalQVTbase.g:18295:1: rule__LetVariableCS__Group_2__0 : rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 ;
    public final void rule__LetVariableCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18299:1: ( rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1 )
            // InternalQVTbase.g:18300:2: rule__LetVariableCS__Group_2__0__Impl rule__LetVariableCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__LetVariableCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__0"


    // $ANTLR start "rule__LetVariableCS__Group_2__0__Impl"
    // InternalQVTbase.g:18307:1: rule__LetVariableCS__Group_2__0__Impl : ( ':' ) ;
    public final void rule__LetVariableCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18311:1: ( ( ':' ) )
            // InternalQVTbase.g:18312:1: ( ':' )
            {
            // InternalQVTbase.g:18312:1: ( ':' )
            // InternalQVTbase.g:18313:1: ':'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0());
            }
            match(input,61,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getColonKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__0__Impl"


    // $ANTLR start "rule__LetVariableCS__Group_2__1"
    // InternalQVTbase.g:18326:1: rule__LetVariableCS__Group_2__1 : rule__LetVariableCS__Group_2__1__Impl ;
    public final void rule__LetVariableCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18330:1: ( rule__LetVariableCS__Group_2__1__Impl )
            // InternalQVTbase.g:18331:2: rule__LetVariableCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__1"


    // $ANTLR start "rule__LetVariableCS__Group_2__1__Impl"
    // InternalQVTbase.g:18337:1: rule__LetVariableCS__Group_2__1__Impl : ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) ;
    public final void rule__LetVariableCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18341:1: ( ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) ) )
            // InternalQVTbase.g:18342:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            {
            // InternalQVTbase.g:18342:1: ( ( rule__LetVariableCS__OwnedTypeAssignment_2_1 ) )
            // InternalQVTbase.g:18343:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1());
            }
            // InternalQVTbase.g:18344:1: ( rule__LetVariableCS__OwnedTypeAssignment_2_1 )
            // InternalQVTbase.g:18344:2: rule__LetVariableCS__OwnedTypeAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__LetVariableCS__OwnedTypeAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedTypeAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__Group_2__1__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__0"
    // InternalQVTbase.g:18358:1: rule__NestedExpCS__Group__0 : rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 ;
    public final void rule__NestedExpCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18362:1: ( rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1 )
            // InternalQVTbase.g:18363:2: rule__NestedExpCS__Group__0__Impl rule__NestedExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_62);
            rule__NestedExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__0"


    // $ANTLR start "rule__NestedExpCS__Group__0__Impl"
    // InternalQVTbase.g:18370:1: rule__NestedExpCS__Group__0__Impl : ( '(' ) ;
    public final void rule__NestedExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18374:1: ( ( '(' ) )
            // InternalQVTbase.g:18375:1: ( '(' )
            {
            // InternalQVTbase.g:18375:1: ( '(' )
            // InternalQVTbase.g:18376:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getLeftParenthesisKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__0__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__1"
    // InternalQVTbase.g:18389:1: rule__NestedExpCS__Group__1 : rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 ;
    public final void rule__NestedExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18393:1: ( rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2 )
            // InternalQVTbase.g:18394:2: rule__NestedExpCS__Group__1__Impl rule__NestedExpCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_56);
            rule__NestedExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__1"


    // $ANTLR start "rule__NestedExpCS__Group__1__Impl"
    // InternalQVTbase.g:18401:1: rule__NestedExpCS__Group__1__Impl : ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) ;
    public final void rule__NestedExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18405:1: ( ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) ) )
            // InternalQVTbase.g:18406:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            {
            // InternalQVTbase.g:18406:1: ( ( rule__NestedExpCS__OwnedExpressionAssignment_1 ) )
            // InternalQVTbase.g:18407:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1());
            }
            // InternalQVTbase.g:18408:1: ( rule__NestedExpCS__OwnedExpressionAssignment_1 )
            // InternalQVTbase.g:18408:2: rule__NestedExpCS__OwnedExpressionAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__OwnedExpressionAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__1__Impl"


    // $ANTLR start "rule__NestedExpCS__Group__2"
    // InternalQVTbase.g:18418:1: rule__NestedExpCS__Group__2 : rule__NestedExpCS__Group__2__Impl ;
    public final void rule__NestedExpCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18422:1: ( rule__NestedExpCS__Group__2__Impl )
            // InternalQVTbase.g:18423:2: rule__NestedExpCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__NestedExpCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__2"


    // $ANTLR start "rule__NestedExpCS__Group__2__Impl"
    // InternalQVTbase.g:18429:1: rule__NestedExpCS__Group__2__Impl : ( ')' ) ;
    public final void rule__NestedExpCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18433:1: ( ( ')' ) )
            // InternalQVTbase.g:18434:1: ( ')' )
            {
            // InternalQVTbase.g:18434:1: ( ')' )
            // InternalQVTbase.g:18435:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getRightParenthesisKeyword_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__Group__2__Impl"


    // $ANTLR start "rule__SelfExpCS__Group__0"
    // InternalQVTbase.g:18454: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 {
            // InternalQVTbase.g:18458:1: ( rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1 )
            // InternalQVTbase.g:18459:2: rule__SelfExpCS__Group__0__Impl rule__SelfExpCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_92);
            rule__SelfExpCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__0"


    // $ANTLR start "rule__SelfExpCS__Group__0__Impl"
    // InternalQVTbase.g:18466:1: rule__SelfExpCS__Group__0__Impl : ( () ) ;
    public final void rule__SelfExpCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18470:1: ( ( () ) )
            // InternalQVTbase.g:18471:1: ( () )
            {
            // InternalQVTbase.g:18471:1: ( () )
            // InternalQVTbase.g:18472:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0());
            }
            // InternalQVTbase.g:18473:1: ()
            // InternalQVTbase.g:18475:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSAccess().getSelfExpCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__0__Impl"


    // $ANTLR start "rule__SelfExpCS__Group__1"
    // InternalQVTbase.g:18485:1: rule__SelfExpCS__Group__1 : rule__SelfExpCS__Group__1__Impl ;
    public final void rule__SelfExpCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18489:1: ( rule__SelfExpCS__Group__1__Impl )
            // InternalQVTbase.g:18490:2: rule__SelfExpCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__SelfExpCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__1"


    // $ANTLR start "rule__SelfExpCS__Group__1__Impl"
    // InternalQVTbase.g:18496:1: rule__SelfExpCS__Group__1__Impl : ( 'self' ) ;
    public final void rule__SelfExpCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18500:1: ( ( 'self' ) )
            // InternalQVTbase.g:18501:1: ( 'self' )
            {
            // InternalQVTbase.g:18501:1: ( 'self' )
            // InternalQVTbase.g:18502:1: 'self'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1());
            }
            match(input,96,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSelfExpCSAccess().getSelfKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SelfExpCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__0"
    // InternalQVTbase.g:18519:1: rule__MultiplicityBoundsCS__Group__0 : rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 ;
    public final void rule__MultiplicityBoundsCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18523:1: ( rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1 )
            // InternalQVTbase.g:18524:2: rule__MultiplicityBoundsCS__Group__0__Impl rule__MultiplicityBoundsCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_61);
            rule__MultiplicityBoundsCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__0"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__0__Impl"
    // InternalQVTbase.g:18531:1: rule__MultiplicityBoundsCS__Group__0__Impl : ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) ;
    public final void rule__MultiplicityBoundsCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18535:1: ( ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) ) )
            // InternalQVTbase.g:18536:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            {
            // InternalQVTbase.g:18536:1: ( ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 ) )
            // InternalQVTbase.g:18537:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0());
            }
            // InternalQVTbase.g:18538:1: ( rule__MultiplicityBoundsCS__LowerBoundAssignment_0 )
            // InternalQVTbase.g:18538:2: rule__MultiplicityBoundsCS__LowerBoundAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__LowerBoundAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__0__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__1"
    // InternalQVTbase.g:18548:1: rule__MultiplicityBoundsCS__Group__1 : rule__MultiplicityBoundsCS__Group__1__Impl ;
    public final void rule__MultiplicityBoundsCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18552:1: ( rule__MultiplicityBoundsCS__Group__1__Impl )
            // InternalQVTbase.g:18553:2: rule__MultiplicityBoundsCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__1"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group__1__Impl"
    // InternalQVTbase.g:18559:1: rule__MultiplicityBoundsCS__Group__1__Impl : ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) ;
    public final void rule__MultiplicityBoundsCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18563:1: ( ( ( rule__MultiplicityBoundsCS__Group_1__0 )? ) )
            // InternalQVTbase.g:18564:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:18564:1: ( ( rule__MultiplicityBoundsCS__Group_1__0 )? )
            // InternalQVTbase.g:18565:1: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:18566:1: ( rule__MultiplicityBoundsCS__Group_1__0 )?
            int alt181=2;
            int LA181_0 = input.LA(1);

            if ( (LA181_0==80) ) {
                alt181=1;
            }
            switch (alt181) {
                case 1 :
                    // InternalQVTbase.g:18566:2: rule__MultiplicityBoundsCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityBoundsCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0"
    // InternalQVTbase.g:18580:1: rule__MultiplicityBoundsCS__Group_1__0 : rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 ;
    public final void rule__MultiplicityBoundsCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18584:1: ( rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1 )
            // InternalQVTbase.g:18585:2: rule__MultiplicityBoundsCS__Group_1__0__Impl rule__MultiplicityBoundsCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_93);
            rule__MultiplicityBoundsCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__0__Impl"
    // InternalQVTbase.g:18592:1: rule__MultiplicityBoundsCS__Group_1__0__Impl : ( '..' ) ;
    public final void rule__MultiplicityBoundsCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18596:1: ( ( '..' ) )
            // InternalQVTbase.g:18597:1: ( '..' )
            {
            // InternalQVTbase.g:18597:1: ( '..' )
            // InternalQVTbase.g:18598:1: '..'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0());
            }
            match(input,80,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getFullStopFullStopKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__0__Impl"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1"
    // InternalQVTbase.g:18611:1: rule__MultiplicityBoundsCS__Group_1__1 : rule__MultiplicityBoundsCS__Group_1__1__Impl ;
    public final void rule__MultiplicityBoundsCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18615:1: ( rule__MultiplicityBoundsCS__Group_1__1__Impl )
            // InternalQVTbase.g:18616:2: rule__MultiplicityBoundsCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__1"


    // $ANTLR start "rule__MultiplicityBoundsCS__Group_1__1__Impl"
    // InternalQVTbase.g:18622:1: rule__MultiplicityBoundsCS__Group_1__1__Impl : ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) ;
    public final void rule__MultiplicityBoundsCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18626:1: ( ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) ) )
            // InternalQVTbase.g:18627:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            {
            // InternalQVTbase.g:18627:1: ( ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 ) )
            // InternalQVTbase.g:18628:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1());
            }
            // InternalQVTbase.g:18629:1: ( rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 )
            // InternalQVTbase.g:18629:2: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__Group_1__1__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__0"
    // InternalQVTbase.g:18643: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 {
            // InternalQVTbase.g:18647:1: ( rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1 )
            // InternalQVTbase.g:18648:2: rule__MultiplicityCS__Group__0__Impl rule__MultiplicityCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_94);
            rule__MultiplicityCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__0"


    // $ANTLR start "rule__MultiplicityCS__Group__0__Impl"
    // InternalQVTbase.g:18655:1: rule__MultiplicityCS__Group__0__Impl : ( '[' ) ;
    public final void rule__MultiplicityCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18659:1: ( ( '[' ) )
            // InternalQVTbase.g:18660:1: ( '[' )
            {
            // InternalQVTbase.g:18660:1: ( '[' )
            // InternalQVTbase.g:18661:1: '['
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0());
            }
            match(input,87,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getLeftSquareBracketKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__0__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__1"
    // InternalQVTbase.g:18674: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 {
            // InternalQVTbase.g:18678:1: ( rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2 )
            // InternalQVTbase.g:18679:2: rule__MultiplicityCS__Group__1__Impl rule__MultiplicityCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_95);
            rule__MultiplicityCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__1"


    // $ANTLR start "rule__MultiplicityCS__Group__1__Impl"
    // InternalQVTbase.g:18686:1: rule__MultiplicityCS__Group__1__Impl : ( ( rule__MultiplicityCS__Alternatives_1 ) ) ;
    public final void rule__MultiplicityCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18690:1: ( ( ( rule__MultiplicityCS__Alternatives_1 ) ) )
            // InternalQVTbase.g:18691:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            {
            // InternalQVTbase.g:18691:1: ( ( rule__MultiplicityCS__Alternatives_1 ) )
            // InternalQVTbase.g:18692:1: ( rule__MultiplicityCS__Alternatives_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_1());
            }
            // InternalQVTbase.g:18693:1: ( rule__MultiplicityCS__Alternatives_1 )
            // InternalQVTbase.g:18693:2: rule__MultiplicityCS__Alternatives_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Alternatives_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getAlternatives_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__1__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__2"
    // InternalQVTbase.g:18703:1: rule__MultiplicityCS__Group__2 : rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 ;
    public final void rule__MultiplicityCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18707:1: ( rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3 )
            // InternalQVTbase.g:18708:2: rule__MultiplicityCS__Group__2__Impl rule__MultiplicityCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_95);
            rule__MultiplicityCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__2"


    // $ANTLR start "rule__MultiplicityCS__Group__2__Impl"
    // InternalQVTbase.g:18715:1: rule__MultiplicityCS__Group__2__Impl : ( ( rule__MultiplicityCS__Alternatives_2 )? ) ;
    public final void rule__MultiplicityCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18719:1: ( ( ( rule__MultiplicityCS__Alternatives_2 )? ) )
            // InternalQVTbase.g:18720:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            {
            // InternalQVTbase.g:18720:1: ( ( rule__MultiplicityCS__Alternatives_2 )? )
            // InternalQVTbase.g:18721:1: ( rule__MultiplicityCS__Alternatives_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getAlternatives_2());
            }
            // InternalQVTbase.g:18722:1: ( rule__MultiplicityCS__Alternatives_2 )?
            int alt182=2;
            int LA182_0 = input.LA(1);

            if ( (LA182_0==58||LA182_0==132) ) {
                alt182=1;
            }
            switch (alt182) {
                case 1 :
                    // InternalQVTbase.g:18722:2: rule__MultiplicityCS__Alternatives_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__MultiplicityCS__Alternatives_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getAlternatives_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__2__Impl"


    // $ANTLR start "rule__MultiplicityCS__Group__3"
    // InternalQVTbase.g:18732:1: rule__MultiplicityCS__Group__3 : rule__MultiplicityCS__Group__3__Impl ;
    public final void rule__MultiplicityCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18736:1: ( rule__MultiplicityCS__Group__3__Impl )
            // InternalQVTbase.g:18737:2: rule__MultiplicityCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__3"


    // $ANTLR start "rule__MultiplicityCS__Group__3__Impl"
    // InternalQVTbase.g:18743:1: rule__MultiplicityCS__Group__3__Impl : ( ']' ) ;
    public final void rule__MultiplicityCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18747:1: ( ( ']' ) )
            // InternalQVTbase.g:18748:1: ( ']' )
            {
            // InternalQVTbase.g:18748:1: ( ']' )
            // InternalQVTbase.g:18749:1: ']'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3());
            }
            match(input,88,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getRightSquareBracketKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__Group__3__Impl"


    // $ANTLR start "rule__PathNameCS__Group__0"
    // InternalQVTbase.g:18770: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 {
            // InternalQVTbase.g:18774:1: ( rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1 )
            // InternalQVTbase.g:18775:2: rule__PathNameCS__Group__0__Impl rule__PathNameCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_96);
            rule__PathNameCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__0"


    // $ANTLR start "rule__PathNameCS__Group__0__Impl"
    // InternalQVTbase.g:18782:1: rule__PathNameCS__Group__0__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) ;
    public final void rule__PathNameCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18786:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) ) )
            // InternalQVTbase.g:18787:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            {
            // InternalQVTbase.g:18787:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_0 ) )
            // InternalQVTbase.g:18788:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0());
            }
            // InternalQVTbase.g:18789:1: ( rule__PathNameCS__OwnedPathElementsAssignment_0 )
            // InternalQVTbase.g:18789:2: rule__PathNameCS__OwnedPathElementsAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__OwnedPathElementsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__0__Impl"


    // $ANTLR start "rule__PathNameCS__Group__1"
    // InternalQVTbase.g:18799:1: rule__PathNameCS__Group__1 : rule__PathNameCS__Group__1__Impl ;
    public final void rule__PathNameCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18803:1: ( rule__PathNameCS__Group__1__Impl )
            // InternalQVTbase.g:18804:2: rule__PathNameCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group__1"


    // $ANTLR start "rule__PathNameCS__Group__1__Impl"
    // InternalQVTbase.g:18810: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 {
            // InternalQVTbase.g:18814:1: ( ( ( rule__PathNameCS__Group_1__0 )* ) )
            // InternalQVTbase.g:18815:1: ( ( rule__PathNameCS__Group_1__0 )* )
            {
            // InternalQVTbase.g:18815:1: ( ( rule__PathNameCS__Group_1__0 )* )
            // InternalQVTbase.g:18816:1: ( rule__PathNameCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:18817:1: ( rule__PathNameCS__Group_1__0 )*
            loop183:
            do {
                int alt183=2;
                int LA183_0 = input.LA(1);

                if ( (LA183_0==97) ) {
                    alt183=1;
                }


                switch (alt183) {
            	case 1 :
            	    // InternalQVTbase.g:18817:2: rule__PathNameCS__Group_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_97);
            	    rule__PathNameCS__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop183;
                }
            } 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"
    // InternalQVTbase.g:18831: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 {
            // InternalQVTbase.g:18835:1: ( rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1 )
            // InternalQVTbase.g:18836:2: rule__PathNameCS__Group_1__0__Impl rule__PathNameCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__PathNameCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__0"


    // $ANTLR start "rule__PathNameCS__Group_1__0__Impl"
    // InternalQVTbase.g:18843:1: rule__PathNameCS__Group_1__0__Impl : ( '::' ) ;
    public final void rule__PathNameCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18847:1: ( ( '::' ) )
            // InternalQVTbase.g:18848:1: ( '::' )
            {
            // InternalQVTbase.g:18848:1: ( '::' )
            // InternalQVTbase.g:18849:1: '::'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0());
            }
            match(input,97,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getColonColonKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__0__Impl"


    // $ANTLR start "rule__PathNameCS__Group_1__1"
    // InternalQVTbase.g:18862: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 {
            // InternalQVTbase.g:18866:1: ( rule__PathNameCS__Group_1__1__Impl )
            // InternalQVTbase.g:18867:2: rule__PathNameCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__1"


    // $ANTLR start "rule__PathNameCS__Group_1__1__Impl"
    // InternalQVTbase.g:18873:1: rule__PathNameCS__Group_1__1__Impl : ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) ;
    public final void rule__PathNameCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18877:1: ( ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) ) )
            // InternalQVTbase.g:18878:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            {
            // InternalQVTbase.g:18878:1: ( ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 ) )
            // InternalQVTbase.g:18879:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1());
            }
            // InternalQVTbase.g:18880:1: ( rule__PathNameCS__OwnedPathElementsAssignment_1_1 )
            // InternalQVTbase.g:18880:2: rule__PathNameCS__OwnedPathElementsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__PathNameCS__OwnedPathElementsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__Group_1__1__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__0"
    // InternalQVTbase.g:18894:1: rule__TemplateBindingCS__Group__0 : rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 ;
    public final void rule__TemplateBindingCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18898:1: ( rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1 )
            // InternalQVTbase.g:18899:2: rule__TemplateBindingCS__Group__0__Impl rule__TemplateBindingCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_98);
            rule__TemplateBindingCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__0"


    // $ANTLR start "rule__TemplateBindingCS__Group__0__Impl"
    // InternalQVTbase.g:18906:1: rule__TemplateBindingCS__Group__0__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) ;
    public final void rule__TemplateBindingCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18910:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) ) )
            // InternalQVTbase.g:18911:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            {
            // InternalQVTbase.g:18911:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 ) )
            // InternalQVTbase.g:18912:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0());
            }
            // InternalQVTbase.g:18913:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 )
            // InternalQVTbase.g:18913:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__0__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__1"
    // InternalQVTbase.g:18923:1: rule__TemplateBindingCS__Group__1 : rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 ;
    public final void rule__TemplateBindingCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18927:1: ( rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2 )
            // InternalQVTbase.g:18928:2: rule__TemplateBindingCS__Group__1__Impl rule__TemplateBindingCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_98);
            rule__TemplateBindingCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__1"


    // $ANTLR start "rule__TemplateBindingCS__Group__1__Impl"
    // InternalQVTbase.g:18935:1: rule__TemplateBindingCS__Group__1__Impl : ( ( rule__TemplateBindingCS__Group_1__0 )* ) ;
    public final void rule__TemplateBindingCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18939:1: ( ( ( rule__TemplateBindingCS__Group_1__0 )* ) )
            // InternalQVTbase.g:18940:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            {
            // InternalQVTbase.g:18940:1: ( ( rule__TemplateBindingCS__Group_1__0 )* )
            // InternalQVTbase.g:18941:1: ( rule__TemplateBindingCS__Group_1__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:18942:1: ( rule__TemplateBindingCS__Group_1__0 )*
            loop184:
            do {
                int alt184=2;
                int LA184_0 = input.LA(1);

                if ( (LA184_0==64) ) {
                    alt184=1;
                }


                switch (alt184) {
            	case 1 :
            	    // InternalQVTbase.g:18942:2: rule__TemplateBindingCS__Group_1__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__TemplateBindingCS__Group_1__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop184;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__1__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group__2"
    // InternalQVTbase.g:18952:1: rule__TemplateBindingCS__Group__2 : rule__TemplateBindingCS__Group__2__Impl ;
    public final void rule__TemplateBindingCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18956:1: ( rule__TemplateBindingCS__Group__2__Impl )
            // InternalQVTbase.g:18957:2: rule__TemplateBindingCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__2"


    // $ANTLR start "rule__TemplateBindingCS__Group__2__Impl"
    // InternalQVTbase.g:18963:1: rule__TemplateBindingCS__Group__2__Impl : ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) ;
    public final void rule__TemplateBindingCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18967:1: ( ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? ) )
            // InternalQVTbase.g:18968:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            {
            // InternalQVTbase.g:18968:1: ( ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )? )
            // InternalQVTbase.g:18969:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2());
            }
            // InternalQVTbase.g:18970:1: ( rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 )?
            int alt185=2;
            int LA185_0 = input.LA(1);

            if ( (LA185_0==87) ) {
                alt185=1;
            }
            switch (alt185) {
                case 1 :
                    // InternalQVTbase.g:18970:2: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TemplateBindingCS__OwnedMultiplicityAssignment_2();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityAssignment_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group__2__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__0"
    // InternalQVTbase.g:18986:1: rule__TemplateBindingCS__Group_1__0 : rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 ;
    public final void rule__TemplateBindingCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:18990:1: ( rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1 )
            // InternalQVTbase.g:18991:2: rule__TemplateBindingCS__Group_1__0__Impl rule__TemplateBindingCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_99);
            rule__TemplateBindingCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__0"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__0__Impl"
    // InternalQVTbase.g:18998:1: rule__TemplateBindingCS__Group_1__0__Impl : ( ',' ) ;
    public final void rule__TemplateBindingCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19002:1: ( ( ',' ) )
            // InternalQVTbase.g:19003:1: ( ',' )
            {
            // InternalQVTbase.g:19003:1: ( ',' )
            // InternalQVTbase.g:19004:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getCommaKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__0__Impl"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__1"
    // InternalQVTbase.g:19017:1: rule__TemplateBindingCS__Group_1__1 : rule__TemplateBindingCS__Group_1__1__Impl ;
    public final void rule__TemplateBindingCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19021:1: ( rule__TemplateBindingCS__Group_1__1__Impl )
            // InternalQVTbase.g:19022:2: rule__TemplateBindingCS__Group_1__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__1"


    // $ANTLR start "rule__TemplateBindingCS__Group_1__1__Impl"
    // InternalQVTbase.g:19028:1: rule__TemplateBindingCS__Group_1__1__Impl : ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) ;
    public final void rule__TemplateBindingCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19032:1: ( ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) ) )
            // InternalQVTbase.g:19033:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            {
            // InternalQVTbase.g:19033:1: ( ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 ) )
            // InternalQVTbase.g:19034:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1());
            }
            // InternalQVTbase.g:19035:1: ( rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 )
            // InternalQVTbase.g:19035:2: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__Group_1__1__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group__0"
    // InternalQVTbase.g:19049:1: rule__TemplateSignatureCS__Group__0 : rule__TemplateSignatureCS__Group__0__Impl rule__TemplateSignatureCS__Group__1 ;
    public final void rule__TemplateSignatureCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19053:1: ( rule__TemplateSignatureCS__Group__0__Impl rule__TemplateSignatureCS__Group__1 )
            // InternalQVTbase.g:19054:2: rule__TemplateSignatureCS__Group__0__Impl rule__TemplateSignatureCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TemplateSignatureCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__0"


    // $ANTLR start "rule__TemplateSignatureCS__Group__0__Impl"
    // InternalQVTbase.g:19061:1: rule__TemplateSignatureCS__Group__0__Impl : ( '(' ) ;
    public final void rule__TemplateSignatureCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19065:1: ( ( '(' ) )
            // InternalQVTbase.g:19066:1: ( '(' )
            {
            // InternalQVTbase.g:19066:1: ( '(' )
            // InternalQVTbase.g:19067:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getLeftParenthesisKeyword_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getLeftParenthesisKeyword_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__0__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group__1"
    // InternalQVTbase.g:19080:1: rule__TemplateSignatureCS__Group__1 : rule__TemplateSignatureCS__Group__1__Impl rule__TemplateSignatureCS__Group__2 ;
    public final void rule__TemplateSignatureCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19084:1: ( rule__TemplateSignatureCS__Group__1__Impl rule__TemplateSignatureCS__Group__2 )
            // InternalQVTbase.g:19085:2: rule__TemplateSignatureCS__Group__1__Impl rule__TemplateSignatureCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_100);
            rule__TemplateSignatureCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__1"


    // $ANTLR start "rule__TemplateSignatureCS__Group__1__Impl"
    // InternalQVTbase.g:19092:1: rule__TemplateSignatureCS__Group__1__Impl : ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 ) ) ;
    public final void rule__TemplateSignatureCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19096:1: ( ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 ) ) )
            // InternalQVTbase.g:19097:1: ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 ) )
            {
            // InternalQVTbase.g:19097:1: ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 ) )
            // InternalQVTbase.g:19098:1: ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersAssignment_1());
            }
            // InternalQVTbase.g:19099:1: ( rule__TemplateSignatureCS__OwnedParametersAssignment_1 )
            // InternalQVTbase.g:19099:2: rule__TemplateSignatureCS__OwnedParametersAssignment_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__OwnedParametersAssignment_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersAssignment_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__1__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group__2"
    // InternalQVTbase.g:19109:1: rule__TemplateSignatureCS__Group__2 : rule__TemplateSignatureCS__Group__2__Impl rule__TemplateSignatureCS__Group__3 ;
    public final void rule__TemplateSignatureCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19113:1: ( rule__TemplateSignatureCS__Group__2__Impl rule__TemplateSignatureCS__Group__3 )
            // InternalQVTbase.g:19114:2: rule__TemplateSignatureCS__Group__2__Impl rule__TemplateSignatureCS__Group__3
            {
            pushFollow(FollowSets000.FOLLOW_100);
            rule__TemplateSignatureCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group__3();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__2"


    // $ANTLR start "rule__TemplateSignatureCS__Group__2__Impl"
    // InternalQVTbase.g:19121:1: rule__TemplateSignatureCS__Group__2__Impl : ( ( rule__TemplateSignatureCS__Group_2__0 )* ) ;
    public final void rule__TemplateSignatureCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19125:1: ( ( ( rule__TemplateSignatureCS__Group_2__0 )* ) )
            // InternalQVTbase.g:19126:1: ( ( rule__TemplateSignatureCS__Group_2__0 )* )
            {
            // InternalQVTbase.g:19126:1: ( ( rule__TemplateSignatureCS__Group_2__0 )* )
            // InternalQVTbase.g:19127:1: ( rule__TemplateSignatureCS__Group_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:19128:1: ( rule__TemplateSignatureCS__Group_2__0 )*
            loop186:
            do {
                int alt186=2;
                int LA186_0 = input.LA(1);

                if ( (LA186_0==64) ) {
                    alt186=1;
                }


                switch (alt186) {
            	case 1 :
            	    // InternalQVTbase.g:19128:2: rule__TemplateSignatureCS__Group_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_34);
            	    rule__TemplateSignatureCS__Group_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop186;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__2__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group__3"
    // InternalQVTbase.g:19138:1: rule__TemplateSignatureCS__Group__3 : rule__TemplateSignatureCS__Group__3__Impl ;
    public final void rule__TemplateSignatureCS__Group__3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19142:1: ( rule__TemplateSignatureCS__Group__3__Impl )
            // InternalQVTbase.g:19143:2: rule__TemplateSignatureCS__Group__3__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group__3__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__3"


    // $ANTLR start "rule__TemplateSignatureCS__Group__3__Impl"
    // InternalQVTbase.g:19149:1: rule__TemplateSignatureCS__Group__3__Impl : ( ')' ) ;
    public final void rule__TemplateSignatureCS__Group__3__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19153:1: ( ( ')' ) )
            // InternalQVTbase.g:19154:1: ( ')' )
            {
            // InternalQVTbase.g:19154:1: ( ')' )
            // InternalQVTbase.g:19155:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getRightParenthesisKeyword_3());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getRightParenthesisKeyword_3());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group__3__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group_2__0"
    // InternalQVTbase.g:19176:1: rule__TemplateSignatureCS__Group_2__0 : rule__TemplateSignatureCS__Group_2__0__Impl rule__TemplateSignatureCS__Group_2__1 ;
    public final void rule__TemplateSignatureCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19180:1: ( rule__TemplateSignatureCS__Group_2__0__Impl rule__TemplateSignatureCS__Group_2__1 )
            // InternalQVTbase.g:19181:2: rule__TemplateSignatureCS__Group_2__0__Impl rule__TemplateSignatureCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_5);
            rule__TemplateSignatureCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group_2__0"


    // $ANTLR start "rule__TemplateSignatureCS__Group_2__0__Impl"
    // InternalQVTbase.g:19188:1: rule__TemplateSignatureCS__Group_2__0__Impl : ( ',' ) ;
    public final void rule__TemplateSignatureCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19192:1: ( ( ',' ) )
            // InternalQVTbase.g:19193:1: ( ',' )
            {
            // InternalQVTbase.g:19193:1: ( ',' )
            // InternalQVTbase.g:19194:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getCommaKeyword_2_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getCommaKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group_2__0__Impl"


    // $ANTLR start "rule__TemplateSignatureCS__Group_2__1"
    // InternalQVTbase.g:19207:1: rule__TemplateSignatureCS__Group_2__1 : rule__TemplateSignatureCS__Group_2__1__Impl ;
    public final void rule__TemplateSignatureCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19211:1: ( rule__TemplateSignatureCS__Group_2__1__Impl )
            // InternalQVTbase.g:19212:2: rule__TemplateSignatureCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__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__TemplateSignatureCS__Group_2__1"


    // $ANTLR start "rule__TemplateSignatureCS__Group_2__1__Impl"
    // InternalQVTbase.g:19218:1: rule__TemplateSignatureCS__Group_2__1__Impl : ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 ) ) ;
    public final void rule__TemplateSignatureCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19222:1: ( ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 ) ) )
            // InternalQVTbase.g:19223:1: ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 ) )
            {
            // InternalQVTbase.g:19223:1: ( ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 ) )
            // InternalQVTbase.g:19224:1: ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersAssignment_2_1());
            }
            // InternalQVTbase.g:19225:1: ( rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 )
            // InternalQVTbase.g:19225:2: rule__TemplateSignatureCS__OwnedParametersAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TemplateSignatureCS__OwnedParametersAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__Group_2__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group__0"
    // InternalQVTbase.g:19239:1: rule__TypeParameterCS__Group__0 : rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 ;
    public final void rule__TypeParameterCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19243:1: ( rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1 )
            // InternalQVTbase.g:19244:2: rule__TypeParameterCS__Group__0__Impl rule__TypeParameterCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_101);
            rule__TypeParameterCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__0"


    // $ANTLR start "rule__TypeParameterCS__Group__0__Impl"
    // InternalQVTbase.g:19251:1: rule__TypeParameterCS__Group__0__Impl : ( ( rule__TypeParameterCS__NameAssignment_0 ) ) ;
    public final void rule__TypeParameterCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19255:1: ( ( ( rule__TypeParameterCS__NameAssignment_0 ) ) )
            // InternalQVTbase.g:19256:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            {
            // InternalQVTbase.g:19256:1: ( ( rule__TypeParameterCS__NameAssignment_0 ) )
            // InternalQVTbase.g:19257:1: ( rule__TypeParameterCS__NameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0());
            }
            // InternalQVTbase.g:19258:1: ( rule__TypeParameterCS__NameAssignment_0 )
            // InternalQVTbase.g:19258:2: rule__TypeParameterCS__NameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__NameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group__1"
    // InternalQVTbase.g:19268:1: rule__TypeParameterCS__Group__1 : rule__TypeParameterCS__Group__1__Impl ;
    public final void rule__TypeParameterCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19272:1: ( rule__TypeParameterCS__Group__1__Impl )
            // InternalQVTbase.g:19273:2: rule__TypeParameterCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__1"


    // $ANTLR start "rule__TypeParameterCS__Group__1__Impl"
    // InternalQVTbase.g:19279:1: rule__TypeParameterCS__Group__1__Impl : ( ( rule__TypeParameterCS__Group_1__0 )? ) ;
    public final void rule__TypeParameterCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19283:1: ( ( ( rule__TypeParameterCS__Group_1__0 )? ) )
            // InternalQVTbase.g:19284:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:19284:1: ( ( rule__TypeParameterCS__Group_1__0 )? )
            // InternalQVTbase.g:19285:1: ( rule__TypeParameterCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:19286:1: ( rule__TypeParameterCS__Group_1__0 )?
            int alt187=2;
            int LA187_0 = input.LA(1);

            if ( (LA187_0==79) ) {
                alt187=1;
            }
            switch (alt187) {
                case 1 :
                    // InternalQVTbase.g:19286:2: rule__TypeParameterCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypeParameterCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__0"
    // InternalQVTbase.g:19300:1: rule__TypeParameterCS__Group_1__0 : rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 ;
    public final void rule__TypeParameterCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19304:1: ( rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1 )
            // InternalQVTbase.g:19305:2: rule__TypeParameterCS__Group_1__0__Impl rule__TypeParameterCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__TypeParameterCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__0"


    // $ANTLR start "rule__TypeParameterCS__Group_1__0__Impl"
    // InternalQVTbase.g:19312:1: rule__TypeParameterCS__Group_1__0__Impl : ( 'extends' ) ;
    public final void rule__TypeParameterCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19316:1: ( ( 'extends' ) )
            // InternalQVTbase.g:19317:1: ( 'extends' )
            {
            // InternalQVTbase.g:19317:1: ( 'extends' )
            // InternalQVTbase.g:19318:1: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0());
            }
            match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getExtendsKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__1"
    // InternalQVTbase.g:19331:1: rule__TypeParameterCS__Group_1__1 : rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 ;
    public final void rule__TypeParameterCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19335:1: ( rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2 )
            // InternalQVTbase.g:19336:2: rule__TypeParameterCS__Group_1__1__Impl rule__TypeParameterCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_102);
            rule__TypeParameterCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__1"


    // $ANTLR start "rule__TypeParameterCS__Group_1__1__Impl"
    // InternalQVTbase.g:19343:1: rule__TypeParameterCS__Group_1__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) ;
    public final void rule__TypeParameterCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19347:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) ) )
            // InternalQVTbase.g:19348:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            {
            // InternalQVTbase.g:19348:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 ) )
            // InternalQVTbase.g:19349:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1());
            }
            // InternalQVTbase.g:19350:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_1 )
            // InternalQVTbase.g:19350:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__OwnedExtendsAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1__2"
    // InternalQVTbase.g:19360:1: rule__TypeParameterCS__Group_1__2 : rule__TypeParameterCS__Group_1__2__Impl ;
    public final void rule__TypeParameterCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19364:1: ( rule__TypeParameterCS__Group_1__2__Impl )
            // InternalQVTbase.g:19365:2: rule__TypeParameterCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__2"


    // $ANTLR start "rule__TypeParameterCS__Group_1__2__Impl"
    // InternalQVTbase.g:19371:1: rule__TypeParameterCS__Group_1__2__Impl : ( ( rule__TypeParameterCS__Group_1_2__0 )* ) ;
    public final void rule__TypeParameterCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19375:1: ( ( ( rule__TypeParameterCS__Group_1_2__0 )* ) )
            // InternalQVTbase.g:19376:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            {
            // InternalQVTbase.g:19376:1: ( ( rule__TypeParameterCS__Group_1_2__0 )* )
            // InternalQVTbase.g:19377:1: ( rule__TypeParameterCS__Group_1_2__0 )*
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getGroup_1_2());
            }
            // InternalQVTbase.g:19378:1: ( rule__TypeParameterCS__Group_1_2__0 )*
            loop188:
            do {
                int alt188=2;
                int LA188_0 = input.LA(1);

                if ( (LA188_0==98) ) {
                    alt188=1;
                }


                switch (alt188) {
            	case 1 :
            	    // InternalQVTbase.g:19378:2: rule__TypeParameterCS__Group_1_2__0
            	    {
            	    pushFollow(FollowSets000.FOLLOW_103);
            	    rule__TypeParameterCS__Group_1_2__0();

            	    state._fsp--;
            	    if (state.failed) return ;

            	    }
            	    break;

            	default :
            	    break loop188;
                }
            } while (true);

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getGroup_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1__2__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__0"
    // InternalQVTbase.g:19394:1: rule__TypeParameterCS__Group_1_2__0 : rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 ;
    public final void rule__TypeParameterCS__Group_1_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19398:1: ( rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1 )
            // InternalQVTbase.g:19399:2: rule__TypeParameterCS__Group_1_2__0__Impl rule__TypeParameterCS__Group_1_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__TypeParameterCS__Group_1_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__0"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__0__Impl"
    // InternalQVTbase.g:19406:1: rule__TypeParameterCS__Group_1_2__0__Impl : ( '&&' ) ;
    public final void rule__TypeParameterCS__Group_1_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19410:1: ( ( '&&' ) )
            // InternalQVTbase.g:19411:1: ( '&&' )
            {
            // InternalQVTbase.g:19411:1: ( '&&' )
            // InternalQVTbase.g:19412:1: '&&'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0());
            }
            match(input,98,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getAmpersandAmpersandKeyword_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__0__Impl"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__1"
    // InternalQVTbase.g:19425:1: rule__TypeParameterCS__Group_1_2__1 : rule__TypeParameterCS__Group_1_2__1__Impl ;
    public final void rule__TypeParameterCS__Group_1_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19429:1: ( rule__TypeParameterCS__Group_1_2__1__Impl )
            // InternalQVTbase.g:19430:2: rule__TypeParameterCS__Group_1_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__Group_1_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__1"


    // $ANTLR start "rule__TypeParameterCS__Group_1_2__1__Impl"
    // InternalQVTbase.g:19436:1: rule__TypeParameterCS__Group_1_2__1__Impl : ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) ;
    public final void rule__TypeParameterCS__Group_1_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19440:1: ( ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) ) )
            // InternalQVTbase.g:19441:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            {
            // InternalQVTbase.g:19441:1: ( ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 ) )
            // InternalQVTbase.g:19442:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1());
            }
            // InternalQVTbase.g:19443:1: ( rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 )
            // InternalQVTbase.g:19443:2: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsAssignment_1_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__Group_1_2__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group__0"
    // InternalQVTbase.g:19457:1: rule__TypedTypeRefCS__Group__0 : rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 ;
    public final void rule__TypedTypeRefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19461:1: ( rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1 )
            // InternalQVTbase.g:19462:2: rule__TypedTypeRefCS__Group__0__Impl rule__TypedTypeRefCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_31);
            rule__TypedTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__0"


    // $ANTLR start "rule__TypedTypeRefCS__Group__0__Impl"
    // InternalQVTbase.g:19469:1: rule__TypedTypeRefCS__Group__0__Impl : ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) ;
    public final void rule__TypedTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19473:1: ( ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) ) )
            // InternalQVTbase.g:19474:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            {
            // InternalQVTbase.g:19474:1: ( ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 ) )
            // InternalQVTbase.g:19475:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0());
            }
            // InternalQVTbase.g:19476:1: ( rule__TypedTypeRefCS__OwnedPathNameAssignment_0 )
            // InternalQVTbase.g:19476:2: rule__TypedTypeRefCS__OwnedPathNameAssignment_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__OwnedPathNameAssignment_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNameAssignment_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__0__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group__1"
    // InternalQVTbase.g:19486:1: rule__TypedTypeRefCS__Group__1 : rule__TypedTypeRefCS__Group__1__Impl ;
    public final void rule__TypedTypeRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19490:1: ( rule__TypedTypeRefCS__Group__1__Impl )
            // InternalQVTbase.g:19491:2: rule__TypedTypeRefCS__Group__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__1"


    // $ANTLR start "rule__TypedTypeRefCS__Group__1__Impl"
    // InternalQVTbase.g:19497:1: rule__TypedTypeRefCS__Group__1__Impl : ( ( rule__TypedTypeRefCS__Group_1__0 )? ) ;
    public final void rule__TypedTypeRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19501:1: ( ( ( rule__TypedTypeRefCS__Group_1__0 )? ) )
            // InternalQVTbase.g:19502:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            {
            // InternalQVTbase.g:19502:1: ( ( rule__TypedTypeRefCS__Group_1__0 )? )
            // InternalQVTbase.g:19503:1: ( rule__TypedTypeRefCS__Group_1__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getGroup_1());
            }
            // InternalQVTbase.g:19504:1: ( rule__TypedTypeRefCS__Group_1__0 )?
            int alt189=2;
            int LA189_0 = input.LA(1);

            if ( (LA189_0==71) ) {
                alt189=1;
            }
            switch (alt189) {
                case 1 :
                    // InternalQVTbase.g:19504:2: rule__TypedTypeRefCS__Group_1__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__TypedTypeRefCS__Group_1__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getGroup_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__0"
    // InternalQVTbase.g:19518:1: rule__TypedTypeRefCS__Group_1__0 : rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 ;
    public final void rule__TypedTypeRefCS__Group_1__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19522:1: ( rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1 )
            // InternalQVTbase.g:19523:2: rule__TypedTypeRefCS__Group_1__0__Impl rule__TypedTypeRefCS__Group_1__1
            {
            pushFollow(FollowSets000.FOLLOW_99);
            rule__TypedTypeRefCS__Group_1__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__0"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__0__Impl"
    // InternalQVTbase.g:19530:1: rule__TypedTypeRefCS__Group_1__0__Impl : ( '(' ) ;
    public final void rule__TypedTypeRefCS__Group_1__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19534:1: ( ( '(' ) )
            // InternalQVTbase.g:19535:1: ( '(' )
            {
            // InternalQVTbase.g:19535:1: ( '(' )
            // InternalQVTbase.g:19536:1: '('
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0());
            }
            match(input,71,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getLeftParenthesisKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__0__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__1"
    // InternalQVTbase.g:19549:1: rule__TypedTypeRefCS__Group_1__1 : rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 ;
    public final void rule__TypedTypeRefCS__Group_1__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19553:1: ( rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2 )
            // InternalQVTbase.g:19554:2: rule__TypedTypeRefCS__Group_1__1__Impl rule__TypedTypeRefCS__Group_1__2
            {
            pushFollow(FollowSets000.FOLLOW_56);
            rule__TypedTypeRefCS__Group_1__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__1"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__1__Impl"
    // InternalQVTbase.g:19561:1: rule__TypedTypeRefCS__Group_1__1__Impl : ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) ;
    public final void rule__TypedTypeRefCS__Group_1__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19565:1: ( ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) ) )
            // InternalQVTbase.g:19566:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            {
            // InternalQVTbase.g:19566:1: ( ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 ) )
            // InternalQVTbase.g:19567:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1());
            }
            // InternalQVTbase.g:19568:1: ( rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 )
            // InternalQVTbase.g:19568:2: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__OwnedBindingAssignment_1_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingAssignment_1_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__1__Impl"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__2"
    // InternalQVTbase.g:19578:1: rule__TypedTypeRefCS__Group_1__2 : rule__TypedTypeRefCS__Group_1__2__Impl ;
    public final void rule__TypedTypeRefCS__Group_1__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19582:1: ( rule__TypedTypeRefCS__Group_1__2__Impl )
            // InternalQVTbase.g:19583:2: rule__TypedTypeRefCS__Group_1__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__TypedTypeRefCS__Group_1__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__2"


    // $ANTLR start "rule__TypedTypeRefCS__Group_1__2__Impl"
    // InternalQVTbase.g:19589:1: rule__TypedTypeRefCS__Group_1__2__Impl : ( ')' ) ;
    public final void rule__TypedTypeRefCS__Group_1__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19593:1: ( ( ')' ) )
            // InternalQVTbase.g:19594:1: ( ')' )
            {
            // InternalQVTbase.g:19594:1: ( ')' )
            // InternalQVTbase.g:19595:1: ')'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2());
            }
            match(input,72,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getRightParenthesisKeyword_1_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__Group_1__2__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__0"
    // InternalQVTbase.g:19614:1: rule__WildcardTypeRefCS__Group__0 : rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 ;
    public final void rule__WildcardTypeRefCS__Group__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19618:1: ( rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1 )
            // InternalQVTbase.g:19619:2: rule__WildcardTypeRefCS__Group__0__Impl rule__WildcardTypeRefCS__Group__1
            {
            pushFollow(FollowSets000.FOLLOW_99);
            rule__WildcardTypeRefCS__Group__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__0"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__0__Impl"
    // InternalQVTbase.g:19626:1: rule__WildcardTypeRefCS__Group__0__Impl : ( () ) ;
    public final void rule__WildcardTypeRefCS__Group__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19630:1: ( ( () ) )
            // InternalQVTbase.g:19631:1: ( () )
            {
            // InternalQVTbase.g:19631:1: ( () )
            // InternalQVTbase.g:19632:1: ()
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0());
            }
            // InternalQVTbase.g:19633:1: ()
            // InternalQVTbase.g:19635:1:
            {
            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getWildcardTypeRefCSAction_0());
            }

            }


            }

        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__0__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__1"
    // InternalQVTbase.g:19645:1: rule__WildcardTypeRefCS__Group__1 : rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 ;
    public final void rule__WildcardTypeRefCS__Group__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19649:1: ( rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2 )
            // InternalQVTbase.g:19650:2: rule__WildcardTypeRefCS__Group__1__Impl rule__WildcardTypeRefCS__Group__2
            {
            pushFollow(FollowSets000.FOLLOW_101);
            rule__WildcardTypeRefCS__Group__1__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__2();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__1"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__1__Impl"
    // InternalQVTbase.g:19657:1: rule__WildcardTypeRefCS__Group__1__Impl : ( '?' ) ;
    public final void rule__WildcardTypeRefCS__Group__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19661:1: ( ( '?' ) )
            // InternalQVTbase.g:19662:1: ( '?' )
            {
            // InternalQVTbase.g:19662:1: ( '?' )
            // InternalQVTbase.g:19663:1: '?'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1());
            }
            match(input,59,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getQuestionMarkKeyword_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__1__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__2"
    // InternalQVTbase.g:19676:1: rule__WildcardTypeRefCS__Group__2 : rule__WildcardTypeRefCS__Group__2__Impl ;
    public final void rule__WildcardTypeRefCS__Group__2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19680:1: ( rule__WildcardTypeRefCS__Group__2__Impl )
            // InternalQVTbase.g:19681:2: rule__WildcardTypeRefCS__Group__2__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group__2__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__2"


    // $ANTLR start "rule__WildcardTypeRefCS__Group__2__Impl"
    // InternalQVTbase.g:19687:1: rule__WildcardTypeRefCS__Group__2__Impl : ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) ;
    public final void rule__WildcardTypeRefCS__Group__2__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19691:1: ( ( ( rule__WildcardTypeRefCS__Group_2__0 )? ) )
            // InternalQVTbase.g:19692:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            {
            // InternalQVTbase.g:19692:1: ( ( rule__WildcardTypeRefCS__Group_2__0 )? )
            // InternalQVTbase.g:19693:1: ( rule__WildcardTypeRefCS__Group_2__0 )?
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2());
            }
            // InternalQVTbase.g:19694:1: ( rule__WildcardTypeRefCS__Group_2__0 )?
            int alt190=2;
            int LA190_0 = input.LA(1);

            if ( (LA190_0==79) ) {
                alt190=1;
            }
            switch (alt190) {
                case 1 :
                    // InternalQVTbase.g:19694:2: rule__WildcardTypeRefCS__Group_2__0
                    {
                    pushFollow(FollowSets000.FOLLOW_2);
                    rule__WildcardTypeRefCS__Group_2__0();

                    state._fsp--;
                    if (state.failed) return ;

                    }
                    break;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getGroup_2());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group__2__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0"
    // InternalQVTbase.g:19710:1: rule__WildcardTypeRefCS__Group_2__0 : rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 ;
    public final void rule__WildcardTypeRefCS__Group_2__0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19714:1: ( rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1 )
            // InternalQVTbase.g:19715:2: rule__WildcardTypeRefCS__Group_2__0__Impl rule__WildcardTypeRefCS__Group_2__1
            {
            pushFollow(FollowSets000.FOLLOW_9);
            rule__WildcardTypeRefCS__Group_2__0__Impl();

            state._fsp--;
            if (state.failed) return ;
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group_2__1();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__0__Impl"
    // InternalQVTbase.g:19722:1: rule__WildcardTypeRefCS__Group_2__0__Impl : ( 'extends' ) ;
    public final void rule__WildcardTypeRefCS__Group_2__0__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19726:1: ( ( 'extends' ) )
            // InternalQVTbase.g:19727:1: ( 'extends' )
            {
            // InternalQVTbase.g:19727:1: ( 'extends' )
            // InternalQVTbase.g:19728:1: 'extends'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0());
            }
            match(input,79,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getExtendsKeyword_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__0__Impl"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1"
    // InternalQVTbase.g:19741:1: rule__WildcardTypeRefCS__Group_2__1 : rule__WildcardTypeRefCS__Group_2__1__Impl ;
    public final void rule__WildcardTypeRefCS__Group_2__1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19745:1: ( rule__WildcardTypeRefCS__Group_2__1__Impl )
            // InternalQVTbase.g:19746:2: rule__WildcardTypeRefCS__Group_2__1__Impl
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__Group_2__1__Impl();

            state._fsp--;
            if (state.failed) return ;

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__1"


    // $ANTLR start "rule__WildcardTypeRefCS__Group_2__1__Impl"
    // InternalQVTbase.g:19752:1: rule__WildcardTypeRefCS__Group_2__1__Impl : ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) ;
    public final void rule__WildcardTypeRefCS__Group_2__1__Impl() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19756:1: ( ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) ) )
            // InternalQVTbase.g:19757:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            {
            // InternalQVTbase.g:19757:1: ( ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 ) )
            // InternalQVTbase.g:19758:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1());
            }
            // InternalQVTbase.g:19759:1: ( rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 )
            // InternalQVTbase.g:19759:2: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsAssignment_2_1());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__Group_2__1__Impl"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_0_0_0"
    // InternalQVTbase.g:19774:1: rule__AttributeCS__QualifiersAssignment_0_0_0 : ( ( 'static' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_0_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19778:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:19779:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:19779:1: ( ( 'static' ) )
            // InternalQVTbase.g:19780:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            // InternalQVTbase.g:19781:1: ( 'static' )
            // InternalQVTbase.g:19782:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_0_0_0"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_0_0_1"
    // InternalQVTbase.g:19797:1: rule__AttributeCS__QualifiersAssignment_0_0_1 : ( ( 'definition' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_0_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19801:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:19802:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:19802:1: ( ( 'definition' ) )
            // InternalQVTbase.g:19803:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            // InternalQVTbase.g:19804:1: ( 'definition' )
            // InternalQVTbase.g:19805:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_0_0_1"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_0_1_0"
    // InternalQVTbase.g:19820:1: rule__AttributeCS__QualifiersAssignment_0_1_0 : ( ( 'definition' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19824:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:19825:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:19825:1: ( ( 'definition' ) )
            // InternalQVTbase.g:19826:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            // InternalQVTbase.g:19827:1: ( 'definition' )
            // InternalQVTbase.g:19828:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_0_1_0"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_0_1_1"
    // InternalQVTbase.g:19843:1: rule__AttributeCS__QualifiersAssignment_0_1_1 : ( ( 'static' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19847:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:19848:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:19848:1: ( ( 'static' ) )
            // InternalQVTbase.g:19849:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            // InternalQVTbase.g:19850:1: ( 'static' )
            // InternalQVTbase.g:19851:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_0_1_1"


    // $ANTLR start "rule__AttributeCS__NameAssignment_2"
    // InternalQVTbase.g:19866:1: rule__AttributeCS__NameAssignment_2 : ( ruleUnrestrictedName ) ;
    public final void rule__AttributeCS__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19870:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:19871:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:19871:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:19872:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__NameAssignment_2"


    // $ANTLR start "rule__AttributeCS__OwnedTypeAssignment_3_1"
    // InternalQVTbase.g:19881:1: rule__AttributeCS__OwnedTypeAssignment_3_1 : ( ruleTypedMultiplicityRefCS ) ;
    public final void rule__AttributeCS__OwnedTypeAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19885:1: ( ( ruleTypedMultiplicityRefCS ) )
            // InternalQVTbase.g:19886:1: ( ruleTypedMultiplicityRefCS )
            {
            // InternalQVTbase.g:19886:1: ( ruleTypedMultiplicityRefCS )
            // InternalQVTbase.g:19887:1: ruleTypedMultiplicityRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedMultiplicityRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__OwnedTypeAssignment_3_1"


    // $ANTLR start "rule__AttributeCS__DefaultAssignment_4_1"
    // InternalQVTbase.g:19896:1: rule__AttributeCS__DefaultAssignment_4_1 : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void rule__AttributeCS__DefaultAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19900:1: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:19901:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:19901:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:19902:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getDefaultSINGLE_QUOTED_STRINGTerminalRuleCall_4_1_0());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getDefaultSINGLE_QUOTED_STRINGTerminalRuleCall_4_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__DefaultAssignment_4_1"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_0"
    // InternalQVTbase.g:19911:1: rule__AttributeCS__QualifiersAssignment_5_1_0_0 : ( ( 'derived' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19915:1: ( ( ( 'derived' ) ) )
            // InternalQVTbase.g:19916:1: ( ( 'derived' ) )
            {
            // InternalQVTbase.g:19916:1: ( ( 'derived' ) )
            // InternalQVTbase.g:19917:1: ( 'derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_0_0());
            }
            // InternalQVTbase.g:19918:1: ( 'derived' )
            // InternalQVTbase.g:19919:1: 'derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_0_0());
            }
            match(input,101,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_0"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_1"
    // InternalQVTbase.g:19934:1: rule__AttributeCS__QualifiersAssignment_5_1_0_1 : ( ( '!derived' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19938:1: ( ( ( '!derived' ) ) )
            // InternalQVTbase.g:19939:1: ( ( '!derived' ) )
            {
            // InternalQVTbase.g:19939:1: ( ( '!derived' ) )
            // InternalQVTbase.g:19940:1: ( '!derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_1_0());
            }
            // InternalQVTbase.g:19941:1: ( '!derived' )
            // InternalQVTbase.g:19942:1: '!derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_1_0());
            }
            match(input,102,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersDerivedKeyword_5_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_1"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_2"
    // InternalQVTbase.g:19957:1: rule__AttributeCS__QualifiersAssignment_5_1_0_2 : ( ( 'id' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19961:1: ( ( ( 'id' ) ) )
            // InternalQVTbase.g:19962:1: ( ( 'id' ) )
            {
            // InternalQVTbase.g:19962:1: ( ( 'id' ) )
            // InternalQVTbase.g:19963:1: ( 'id' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_2_0());
            }
            // InternalQVTbase.g:19964:1: ( 'id' )
            // InternalQVTbase.g:19965:1: 'id'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_2_0());
            }
            match(input,103,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_2_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_2"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_3"
    // InternalQVTbase.g:19980:1: rule__AttributeCS__QualifiersAssignment_5_1_0_3 : ( ( '!id' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:19984:1: ( ( ( '!id' ) ) )
            // InternalQVTbase.g:19985:1: ( ( '!id' ) )
            {
            // InternalQVTbase.g:19985:1: ( ( '!id' ) )
            // InternalQVTbase.g:19986:1: ( '!id' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_3_0());
            }
            // InternalQVTbase.g:19987:1: ( '!id' )
            // InternalQVTbase.g:19988:1: '!id'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_3_0());
            }
            match(input,104,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_3_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersIdKeyword_5_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_3"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_4"
    // InternalQVTbase.g:20003:1: rule__AttributeCS__QualifiersAssignment_5_1_0_4 : ( ( 'ordered' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20007:1: ( ( ( 'ordered' ) ) )
            // InternalQVTbase.g:20008:1: ( ( 'ordered' ) )
            {
            // InternalQVTbase.g:20008:1: ( ( 'ordered' ) )
            // InternalQVTbase.g:20009:1: ( 'ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_4_0());
            }
            // InternalQVTbase.g:20010:1: ( 'ordered' )
            // InternalQVTbase.g:20011:1: 'ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_4_0());
            }
            match(input,105,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_4_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_4"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_5"
    // InternalQVTbase.g:20026:1: rule__AttributeCS__QualifiersAssignment_5_1_0_5 : ( ( '!ordered' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20030:1: ( ( ( '!ordered' ) ) )
            // InternalQVTbase.g:20031:1: ( ( '!ordered' ) )
            {
            // InternalQVTbase.g:20031:1: ( ( '!ordered' ) )
            // InternalQVTbase.g:20032:1: ( '!ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_5_0());
            }
            // InternalQVTbase.g:20033:1: ( '!ordered' )
            // InternalQVTbase.g:20034:1: '!ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_5_0());
            }
            match(input,106,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_5_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersOrderedKeyword_5_1_0_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_5"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_6"
    // InternalQVTbase.g:20049:1: rule__AttributeCS__QualifiersAssignment_5_1_0_6 : ( ( 'readonly' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20053:1: ( ( ( 'readonly' ) ) )
            // InternalQVTbase.g:20054:1: ( ( 'readonly' ) )
            {
            // InternalQVTbase.g:20054:1: ( ( 'readonly' ) )
            // InternalQVTbase.g:20055:1: ( 'readonly' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_6_0());
            }
            // InternalQVTbase.g:20056:1: ( 'readonly' )
            // InternalQVTbase.g:20057:1: 'readonly'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_6_0());
            }
            match(input,107,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_6_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_6"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_7"
    // InternalQVTbase.g:20072:1: rule__AttributeCS__QualifiersAssignment_5_1_0_7 : ( ( '!readonly' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20076:1: ( ( ( '!readonly' ) ) )
            // InternalQVTbase.g:20077:1: ( ( '!readonly' ) )
            {
            // InternalQVTbase.g:20077:1: ( ( '!readonly' ) )
            // InternalQVTbase.g:20078:1: ( '!readonly' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_7_0());
            }
            // InternalQVTbase.g:20079:1: ( '!readonly' )
            // InternalQVTbase.g:20080:1: '!readonly'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_7_0());
            }
            match(input,108,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_7_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersReadonlyKeyword_5_1_0_7_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_7"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_8"
    // InternalQVTbase.g:20095:1: rule__AttributeCS__QualifiersAssignment_5_1_0_8 : ( ( 'transient' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_8() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20099:1: ( ( ( 'transient' ) ) )
            // InternalQVTbase.g:20100:1: ( ( 'transient' ) )
            {
            // InternalQVTbase.g:20100:1: ( ( 'transient' ) )
            // InternalQVTbase.g:20101:1: ( 'transient' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_8_0());
            }
            // InternalQVTbase.g:20102:1: ( 'transient' )
            // InternalQVTbase.g:20103:1: 'transient'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_8_0());
            }
            match(input,109,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_8_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_8_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_8"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_9"
    // InternalQVTbase.g:20118:1: rule__AttributeCS__QualifiersAssignment_5_1_0_9 : ( ( '!transient' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_9() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20122:1: ( ( ( '!transient' ) ) )
            // InternalQVTbase.g:20123:1: ( ( '!transient' ) )
            {
            // InternalQVTbase.g:20123:1: ( ( '!transient' ) )
            // InternalQVTbase.g:20124:1: ( '!transient' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_9_0());
            }
            // InternalQVTbase.g:20125:1: ( '!transient' )
            // InternalQVTbase.g:20126:1: '!transient'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_9_0());
            }
            match(input,110,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_9_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersTransientKeyword_5_1_0_9_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_9"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_10"
    // InternalQVTbase.g:20141:1: rule__AttributeCS__QualifiersAssignment_5_1_0_10 : ( ( 'unique' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_10() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20145:1: ( ( ( 'unique' ) ) )
            // InternalQVTbase.g:20146:1: ( ( 'unique' ) )
            {
            // InternalQVTbase.g:20146:1: ( ( 'unique' ) )
            // InternalQVTbase.g:20147:1: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_10_0());
            }
            // InternalQVTbase.g:20148:1: ( 'unique' )
            // InternalQVTbase.g:20149:1: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_10_0());
            }
            match(input,111,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_10_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_10_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_10"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_11"
    // InternalQVTbase.g:20164:1: rule__AttributeCS__QualifiersAssignment_5_1_0_11 : ( ( '!unique' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_11() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20168:1: ( ( ( '!unique' ) ) )
            // InternalQVTbase.g:20169:1: ( ( '!unique' ) )
            {
            // InternalQVTbase.g:20169:1: ( ( '!unique' ) )
            // InternalQVTbase.g:20170:1: ( '!unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_11_0());
            }
            // InternalQVTbase.g:20171:1: ( '!unique' )
            // InternalQVTbase.g:20172:1: '!unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_11_0());
            }
            match(input,112,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_11_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUniqueKeyword_5_1_0_11_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_11"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_12"
    // InternalQVTbase.g:20187:1: rule__AttributeCS__QualifiersAssignment_5_1_0_12 : ( ( 'unsettable' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_12() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20191:1: ( ( ( 'unsettable' ) ) )
            // InternalQVTbase.g:20192:1: ( ( 'unsettable' ) )
            {
            // InternalQVTbase.g:20192:1: ( ( 'unsettable' ) )
            // InternalQVTbase.g:20193:1: ( 'unsettable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_12_0());
            }
            // InternalQVTbase.g:20194:1: ( 'unsettable' )
            // InternalQVTbase.g:20195:1: 'unsettable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_12_0());
            }
            match(input,113,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_12_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_12_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_12"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_13"
    // InternalQVTbase.g:20210:1: rule__AttributeCS__QualifiersAssignment_5_1_0_13 : ( ( '!unsettable' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_13() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20214:1: ( ( ( '!unsettable' ) ) )
            // InternalQVTbase.g:20215:1: ( ( '!unsettable' ) )
            {
            // InternalQVTbase.g:20215:1: ( ( '!unsettable' ) )
            // InternalQVTbase.g:20216:1: ( '!unsettable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_13_0());
            }
            // InternalQVTbase.g:20217:1: ( '!unsettable' )
            // InternalQVTbase.g:20218:1: '!unsettable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_13_0());
            }
            match(input,114,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_13_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersUnsettableKeyword_5_1_0_13_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_13"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_14"
    // InternalQVTbase.g:20233:1: rule__AttributeCS__QualifiersAssignment_5_1_0_14 : ( ( 'volatile' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_14() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20237:1: ( ( ( 'volatile' ) ) )
            // InternalQVTbase.g:20238:1: ( ( 'volatile' ) )
            {
            // InternalQVTbase.g:20238:1: ( ( 'volatile' ) )
            // InternalQVTbase.g:20239:1: ( 'volatile' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_14_0());
            }
            // InternalQVTbase.g:20240:1: ( 'volatile' )
            // InternalQVTbase.g:20241:1: 'volatile'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_14_0());
            }
            match(input,115,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_14_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_14_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_14"


    // $ANTLR start "rule__AttributeCS__QualifiersAssignment_5_1_0_15"
    // InternalQVTbase.g:20256:1: rule__AttributeCS__QualifiersAssignment_5_1_0_15 : ( ( '!volatile' ) ) ;
    public final void rule__AttributeCS__QualifiersAssignment_5_1_0_15() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20260:1: ( ( ( '!volatile' ) ) )
            // InternalQVTbase.g:20261:1: ( ( '!volatile' ) )
            {
            // InternalQVTbase.g:20261:1: ( ( '!volatile' ) )
            // InternalQVTbase.g:20262:1: ( '!volatile' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_15_0());
            }
            // InternalQVTbase.g:20263:1: ( '!volatile' )
            // InternalQVTbase.g:20264:1: '!volatile'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_15_0());
            }
            match(input,116,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_15_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getQualifiersVolatileKeyword_5_1_0_15_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__QualifiersAssignment_5_1_0_15"


    // $ANTLR start "rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3"
    // InternalQVTbase.g:20279:1: rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3 : ( ruleSpecificationCS ) ;
    public final void rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20283:1: ( ( ruleSpecificationCS ) )
            // InternalQVTbase.g:20284:1: ( ruleSpecificationCS )
            {
            // InternalQVTbase.g:20284:1: ( ruleSpecificationCS )
            // InternalQVTbase.g:20285:1: ruleSpecificationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_6_0_1_0_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSpecificationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_6_0_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_0_3"


    // $ANTLR start "rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3"
    // InternalQVTbase.g:20294:1: rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3 : ( ruleSpecificationCS ) ;
    public final void rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20298:1: ( ( ruleSpecificationCS ) )
            // InternalQVTbase.g:20299:1: ( ruleSpecificationCS )
            {
            // InternalQVTbase.g:20299:1: ( ruleSpecificationCS )
            // InternalQVTbase.g:20300:1: ruleSpecificationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_6_0_1_1_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSpecificationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getAttributeCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_6_0_1_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__AttributeCS__OwnedDefaultExpressionsAssignment_6_0_1_1_3"


    // $ANTLR start "rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1"
    // InternalQVTbase.g:20309:1: rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1 : ( ruleSimpleTargetElementCS ) ;
    public final void rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20313:1: ( ( ruleSimpleTargetElementCS ) )
            // InternalQVTbase.g:20314:1: ( ruleSimpleTargetElementCS )
            {
            // InternalQVTbase.g:20314:1: ( ruleSimpleTargetElementCS )
            // InternalQVTbase.g:20315:1: ruleSimpleTargetElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCompoundTargetElementCSAccess().getOwnedTargetElementsSimpleTargetElementCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSimpleTargetElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCompoundTargetElementCSAccess().getOwnedTargetElementsSimpleTargetElementCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CompoundTargetElementCS__OwnedTargetElementsAssignment_1"


    // $ANTLR start "rule__DataTypeCS__IsPrimitiveAssignment_0"
    // InternalQVTbase.g:20324:1: rule__DataTypeCS__IsPrimitiveAssignment_0 : ( ( 'primitive' ) ) ;
    public final void rule__DataTypeCS__IsPrimitiveAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20328:1: ( ( ( 'primitive' ) ) )
            // InternalQVTbase.g:20329:1: ( ( 'primitive' ) )
            {
            // InternalQVTbase.g:20329:1: ( ( 'primitive' ) )
            // InternalQVTbase.g:20330:1: ( 'primitive' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getIsPrimitivePrimitiveKeyword_0_0());
            }
            // InternalQVTbase.g:20331:1: ( 'primitive' )
            // InternalQVTbase.g:20332:1: 'primitive'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getIsPrimitivePrimitiveKeyword_0_0());
            }
            match(input,117,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getIsPrimitivePrimitiveKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getIsPrimitivePrimitiveKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__IsPrimitiveAssignment_0"


    // $ANTLR start "rule__DataTypeCS__NameAssignment_2"
    // InternalQVTbase.g:20347:1: rule__DataTypeCS__NameAssignment_2 : ( ruleUnrestrictedName ) ;
    public final void rule__DataTypeCS__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20351:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:20352:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:20352:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:20353:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__NameAssignment_2"


    // $ANTLR start "rule__DataTypeCS__OwnedSignatureAssignment_3"
    // InternalQVTbase.g:20362:1: rule__DataTypeCS__OwnedSignatureAssignment_3 : ( ruleTemplateSignatureCS ) ;
    public final void rule__DataTypeCS__OwnedSignatureAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20366:1: ( ( ruleTemplateSignatureCS ) )
            // InternalQVTbase.g:20367:1: ( ruleTemplateSignatureCS )
            {
            // InternalQVTbase.g:20367:1: ( ruleTemplateSignatureCS )
            // InternalQVTbase.g:20368:1: ruleTemplateSignatureCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateSignatureCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__OwnedSignatureAssignment_3"


    // $ANTLR start "rule__DataTypeCS__InstanceClassNameAssignment_4_1"
    // InternalQVTbase.g:20377:1: rule__DataTypeCS__InstanceClassNameAssignment_4_1 : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void rule__DataTypeCS__InstanceClassNameAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20381:1: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:20382:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:20382:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:20383:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_4_1_0());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_4_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__InstanceClassNameAssignment_4_1"


    // $ANTLR start "rule__DataTypeCS__IsSerializableAssignment_5_1_0"
    // InternalQVTbase.g:20392:1: rule__DataTypeCS__IsSerializableAssignment_5_1_0 : ( ( 'serializable' ) ) ;
    public final void rule__DataTypeCS__IsSerializableAssignment_5_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20396:1: ( ( ( 'serializable' ) ) )
            // InternalQVTbase.g:20397:1: ( ( 'serializable' ) )
            {
            // InternalQVTbase.g:20397:1: ( ( 'serializable' ) )
            // InternalQVTbase.g:20398:1: ( 'serializable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getIsSerializableSerializableKeyword_5_1_0_0());
            }
            // InternalQVTbase.g:20399:1: ( 'serializable' )
            // InternalQVTbase.g:20400:1: 'serializable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getDataTypeCSAccess().getIsSerializableSerializableKeyword_5_1_0_0());
            }
            match(input,118,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getIsSerializableSerializableKeyword_5_1_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getDataTypeCSAccess().getIsSerializableSerializableKeyword_5_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__DataTypeCS__IsSerializableAssignment_5_1_0"


    // $ANTLR start "rule__EnumerationCS__NameAssignment_1"
    // InternalQVTbase.g:20415:1: rule__EnumerationCS__NameAssignment_1 : ( ruleUnrestrictedName ) ;
    public final void rule__EnumerationCS__NameAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20419:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:20420:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:20420:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:20421:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getNameUnrestrictedNameParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getNameUnrestrictedNameParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__NameAssignment_1"


    // $ANTLR start "rule__EnumerationCS__OwnedSignatureAssignment_2"
    // InternalQVTbase.g:20430:1: rule__EnumerationCS__OwnedSignatureAssignment_2 : ( ruleTemplateSignatureCS ) ;
    public final void rule__EnumerationCS__OwnedSignatureAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20434:1: ( ( ruleTemplateSignatureCS ) )
            // InternalQVTbase.g:20435:1: ( ruleTemplateSignatureCS )
            {
            // InternalQVTbase.g:20435:1: ( ruleTemplateSignatureCS )
            // InternalQVTbase.g:20436:1: ruleTemplateSignatureCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateSignatureCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__OwnedSignatureAssignment_2"


    // $ANTLR start "rule__EnumerationCS__InstanceClassNameAssignment_3_1"
    // InternalQVTbase.g:20445:1: rule__EnumerationCS__InstanceClassNameAssignment_3_1 : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void rule__EnumerationCS__InstanceClassNameAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20449:1: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:20450:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:20450:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:20451:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_3_1_0());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__InstanceClassNameAssignment_3_1"


    // $ANTLR start "rule__EnumerationCS__IsSerializableAssignment_4_1_0"
    // InternalQVTbase.g:20460:1: rule__EnumerationCS__IsSerializableAssignment_4_1_0 : ( ( 'serializable' ) ) ;
    public final void rule__EnumerationCS__IsSerializableAssignment_4_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20464:1: ( ( ( 'serializable' ) ) )
            // InternalQVTbase.g:20465:1: ( ( 'serializable' ) )
            {
            // InternalQVTbase.g:20465:1: ( ( 'serializable' ) )
            // InternalQVTbase.g:20466:1: ( 'serializable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getIsSerializableSerializableKeyword_4_1_0_0());
            }
            // InternalQVTbase.g:20467:1: ( 'serializable' )
            // InternalQVTbase.g:20468:1: 'serializable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getIsSerializableSerializableKeyword_4_1_0_0());
            }
            match(input,118,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getIsSerializableSerializableKeyword_4_1_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getIsSerializableSerializableKeyword_4_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__IsSerializableAssignment_4_1_0"


    // $ANTLR start "rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1"
    // InternalQVTbase.g:20483:1: rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1 : ( ruleEnumerationLiteralCS ) ;
    public final void rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20487:1: ( ( ruleEnumerationLiteralCS ) )
            // InternalQVTbase.g:20488:1: ( ruleEnumerationLiteralCS )
            {
            // InternalQVTbase.g:20488:1: ( ruleEnumerationLiteralCS )
            // InternalQVTbase.g:20489:1: ruleEnumerationLiteralCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationCSAccess().getOwnedLiteralsEnumerationLiteralCSParserRuleCall_5_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEnumerationLiteralCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationCSAccess().getOwnedLiteralsEnumerationLiteralCSParserRuleCall_5_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationCS__OwnedLiteralsAssignment_5_0_1"


    // $ANTLR start "rule__EnumerationLiteralCS__NameAssignment_0_0_1"
    // InternalQVTbase.g:20498:1: rule__EnumerationLiteralCS__NameAssignment_0_0_1 : ( ruleUnrestrictedName ) ;
    public final void rule__EnumerationLiteralCS__NameAssignment_0_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20502:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:20503:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:20503:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:20504:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getNameUnrestrictedNameParserRuleCall_0_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getNameUnrestrictedNameParserRuleCall_0_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__NameAssignment_0_0_1"


    // $ANTLR start "rule__EnumerationLiteralCS__NameAssignment_0_1"
    // InternalQVTbase.g:20513:1: rule__EnumerationLiteralCS__NameAssignment_0_1 : ( ruleEnumerationLiteralName ) ;
    public final void rule__EnumerationLiteralCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20517:1: ( ( ruleEnumerationLiteralName ) )
            // InternalQVTbase.g:20518:1: ( ruleEnumerationLiteralName )
            {
            // InternalQVTbase.g:20518:1: ( ruleEnumerationLiteralName )
            // InternalQVTbase.g:20519:1: ruleEnumerationLiteralName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getNameEnumerationLiteralNameParserRuleCall_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleEnumerationLiteralName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getNameEnumerationLiteralNameParserRuleCall_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__NameAssignment_0_1"


    // $ANTLR start "rule__EnumerationLiteralCS__ValueAssignment_1_1"
    // InternalQVTbase.g:20528:1: rule__EnumerationLiteralCS__ValueAssignment_1_1 : ( ruleSIGNED ) ;
    public final void rule__EnumerationLiteralCS__ValueAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20532:1: ( ( ruleSIGNED ) )
            // InternalQVTbase.g:20533:1: ( ruleSIGNED )
            {
            // InternalQVTbase.g:20533:1: ( ruleSIGNED )
            // InternalQVTbase.g:20534:1: ruleSIGNED
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getEnumerationLiteralCSAccess().getValueSIGNEDParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSIGNED();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getEnumerationLiteralCSAccess().getValueSIGNEDParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__EnumerationLiteralCS__ValueAssignment_1_1"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_0_0_0"
    // InternalQVTbase.g:20543:1: rule__OperationCS__QualifiersAssignment_0_0_0 : ( ( 'static' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_0_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20547:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:20548:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:20548:1: ( ( 'static' ) )
            // InternalQVTbase.g:20549:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            // InternalQVTbase.g:20550:1: ( 'static' )
            // InternalQVTbase.g:20551:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_0_0_0"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_0_0_1"
    // InternalQVTbase.g:20566:1: rule__OperationCS__QualifiersAssignment_0_0_1 : ( ( 'definition' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_0_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20570:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:20571:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:20571:1: ( ( 'definition' ) )
            // InternalQVTbase.g:20572:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            // InternalQVTbase.g:20573:1: ( 'definition' )
            // InternalQVTbase.g:20574:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_0_0_1"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_0_1_0"
    // InternalQVTbase.g:20589:1: rule__OperationCS__QualifiersAssignment_0_1_0 : ( ( 'definition' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20593:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:20594:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:20594:1: ( ( 'definition' ) )
            // InternalQVTbase.g:20595:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            // InternalQVTbase.g:20596:1: ( 'definition' )
            // InternalQVTbase.g:20597:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_0_1_0"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_0_1_1"
    // InternalQVTbase.g:20612:1: rule__OperationCS__QualifiersAssignment_0_1_1 : ( ( 'static' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20616:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:20617:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:20617:1: ( ( 'static' ) )
            // InternalQVTbase.g:20618:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            // InternalQVTbase.g:20619:1: ( 'static' )
            // InternalQVTbase.g:20620:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_0_1_1"


    // $ANTLR start "rule__OperationCS__OwnedSignatureAssignment_2"
    // InternalQVTbase.g:20635:1: rule__OperationCS__OwnedSignatureAssignment_2 : ( ruleTemplateSignatureCS ) ;
    public final void rule__OperationCS__OwnedSignatureAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20639:1: ( ( ruleTemplateSignatureCS ) )
            // InternalQVTbase.g:20640:1: ( ruleTemplateSignatureCS )
            {
            // InternalQVTbase.g:20640:1: ( ruleTemplateSignatureCS )
            // InternalQVTbase.g:20641:1: ruleTemplateSignatureCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateSignatureCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedSignatureAssignment_2"


    // $ANTLR start "rule__OperationCS__NameAssignment_3"
    // InternalQVTbase.g:20650:1: rule__OperationCS__NameAssignment_3 : ( ruleUnrestrictedName ) ;
    public final void rule__OperationCS__NameAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20654:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:20655:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:20655:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:20656:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getNameUnrestrictedNameParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getNameUnrestrictedNameParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__NameAssignment_3"


    // $ANTLR start "rule__OperationCS__OwnedParametersAssignment_5_0"
    // InternalQVTbase.g:20665:1: rule__OperationCS__OwnedParametersAssignment_5_0 : ( ruleParameterCS ) ;
    public final void rule__OperationCS__OwnedParametersAssignment_5_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20669:1: ( ( ruleParameterCS ) )
            // InternalQVTbase.g:20670:1: ( ruleParameterCS )
            {
            // InternalQVTbase.g:20670:1: ( ruleParameterCS )
            // InternalQVTbase.g:20671:1: ruleParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedParametersParameterCSParserRuleCall_5_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedParametersParameterCSParserRuleCall_5_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedParametersAssignment_5_0"


    // $ANTLR start "rule__OperationCS__OwnedParametersAssignment_5_1_1"
    // InternalQVTbase.g:20680:1: rule__OperationCS__OwnedParametersAssignment_5_1_1 : ( ruleParameterCS ) ;
    public final void rule__OperationCS__OwnedParametersAssignment_5_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20684:1: ( ( ruleParameterCS ) )
            // InternalQVTbase.g:20685:1: ( ruleParameterCS )
            {
            // InternalQVTbase.g:20685:1: ( ruleParameterCS )
            // InternalQVTbase.g:20686:1: ruleParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedParametersParameterCSParserRuleCall_5_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedParametersParameterCSParserRuleCall_5_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedParametersAssignment_5_1_1"


    // $ANTLR start "rule__OperationCS__OwnedTypeAssignment_7_1"
    // InternalQVTbase.g:20695:1: rule__OperationCS__OwnedTypeAssignment_7_1 : ( ruleTypedMultiplicityRefCS ) ;
    public final void rule__OperationCS__OwnedTypeAssignment_7_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20699:1: ( ( ruleTypedMultiplicityRefCS ) )
            // InternalQVTbase.g:20700:1: ( ruleTypedMultiplicityRefCS )
            {
            // InternalQVTbase.g:20700:1: ( ruleTypedMultiplicityRefCS )
            // InternalQVTbase.g:20701:1: ruleTypedMultiplicityRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_7_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedMultiplicityRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_7_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedTypeAssignment_7_1"


    // $ANTLR start "rule__OperationCS__OwnedExceptionsAssignment_8_1"
    // InternalQVTbase.g:20710:1: rule__OperationCS__OwnedExceptionsAssignment_8_1 : ( ruleTypedRefCS ) ;
    public final void rule__OperationCS__OwnedExceptionsAssignment_8_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20714:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:20715:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:20715:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:20716:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedExceptionsTypedRefCSParserRuleCall_8_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedExceptionsTypedRefCSParserRuleCall_8_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedExceptionsAssignment_8_1"


    // $ANTLR start "rule__OperationCS__OwnedExceptionsAssignment_8_2_1"
    // InternalQVTbase.g:20725:1: rule__OperationCS__OwnedExceptionsAssignment_8_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__OperationCS__OwnedExceptionsAssignment_8_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20729:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:20730:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:20730:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:20731:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedExceptionsTypedRefCSParserRuleCall_8_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedExceptionsTypedRefCSParserRuleCall_8_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedExceptionsAssignment_8_2_1"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_0"
    // InternalQVTbase.g:20740:1: rule__OperationCS__QualifiersAssignment_9_1_0_0 : ( ( 'derived' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20744:1: ( ( ( 'derived' ) ) )
            // InternalQVTbase.g:20745:1: ( ( 'derived' ) )
            {
            // InternalQVTbase.g:20745:1: ( ( 'derived' ) )
            // InternalQVTbase.g:20746:1: ( 'derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_0_0());
            }
            // InternalQVTbase.g:20747:1: ( 'derived' )
            // InternalQVTbase.g:20748:1: 'derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_0_0());
            }
            match(input,101,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_0"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_1"
    // InternalQVTbase.g:20763:1: rule__OperationCS__QualifiersAssignment_9_1_0_1 : ( ( '!derived' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20767:1: ( ( ( '!derived' ) ) )
            // InternalQVTbase.g:20768:1: ( ( '!derived' ) )
            {
            // InternalQVTbase.g:20768:1: ( ( '!derived' ) )
            // InternalQVTbase.g:20769:1: ( '!derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_1_0());
            }
            // InternalQVTbase.g:20770:1: ( '!derived' )
            // InternalQVTbase.g:20771:1: '!derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_1_0());
            }
            match(input,102,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersDerivedKeyword_9_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_1"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_2"
    // InternalQVTbase.g:20786:1: rule__OperationCS__QualifiersAssignment_9_1_0_2 : ( ( 'ordered' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20790:1: ( ( ( 'ordered' ) ) )
            // InternalQVTbase.g:20791:1: ( ( 'ordered' ) )
            {
            // InternalQVTbase.g:20791:1: ( ( 'ordered' ) )
            // InternalQVTbase.g:20792:1: ( 'ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_2_0());
            }
            // InternalQVTbase.g:20793:1: ( 'ordered' )
            // InternalQVTbase.g:20794:1: 'ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_2_0());
            }
            match(input,105,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_2_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_2"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_3"
    // InternalQVTbase.g:20809:1: rule__OperationCS__QualifiersAssignment_9_1_0_3 : ( ( '!ordered' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20813:1: ( ( ( '!ordered' ) ) )
            // InternalQVTbase.g:20814:1: ( ( '!ordered' ) )
            {
            // InternalQVTbase.g:20814:1: ( ( '!ordered' ) )
            // InternalQVTbase.g:20815:1: ( '!ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_3_0());
            }
            // InternalQVTbase.g:20816:1: ( '!ordered' )
            // InternalQVTbase.g:20817:1: '!ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_3_0());
            }
            match(input,106,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_3_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersOrderedKeyword_9_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_3"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_4"
    // InternalQVTbase.g:20832:1: rule__OperationCS__QualifiersAssignment_9_1_0_4 : ( ( 'unique' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20836:1: ( ( ( 'unique' ) ) )
            // InternalQVTbase.g:20837:1: ( ( 'unique' ) )
            {
            // InternalQVTbase.g:20837:1: ( ( 'unique' ) )
            // InternalQVTbase.g:20838:1: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_4_0());
            }
            // InternalQVTbase.g:20839:1: ( 'unique' )
            // InternalQVTbase.g:20840:1: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_4_0());
            }
            match(input,111,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_4_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_4"


    // $ANTLR start "rule__OperationCS__QualifiersAssignment_9_1_0_5"
    // InternalQVTbase.g:20855:1: rule__OperationCS__QualifiersAssignment_9_1_0_5 : ( ( '!unique' ) ) ;
    public final void rule__OperationCS__QualifiersAssignment_9_1_0_5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20859:1: ( ( ( '!unique' ) ) )
            // InternalQVTbase.g:20860:1: ( ( '!unique' ) )
            {
            // InternalQVTbase.g:20860:1: ( ( '!unique' ) )
            // InternalQVTbase.g:20861:1: ( '!unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_5_0());
            }
            // InternalQVTbase.g:20862:1: ( '!unique' )
            // InternalQVTbase.g:20863:1: '!unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_5_0());
            }
            match(input,112,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_5_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getQualifiersUniqueKeyword_9_1_0_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__QualifiersAssignment_9_1_0_5"


    // $ANTLR start "rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3"
    // InternalQVTbase.g:20878:1: rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3 : ( ruleSpecificationCS ) ;
    public final void rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20882:1: ( ( ruleSpecificationCS ) )
            // InternalQVTbase.g:20883:1: ( ruleSpecificationCS )
            {
            // InternalQVTbase.g:20883:1: ( ruleSpecificationCS )
            // InternalQVTbase.g:20884:1: ruleSpecificationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOperationCSAccess().getOwnedBodyExpressionsSpecificationCSParserRuleCall_10_0_1_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSpecificationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getOperationCSAccess().getOwnedBodyExpressionsSpecificationCSParserRuleCall_10_0_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__OperationCS__OwnedBodyExpressionsAssignment_10_0_1_3"


    // $ANTLR start "rule__ParameterCS__NameAssignment_0"
    // InternalQVTbase.g:20893:1: rule__ParameterCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__ParameterCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20897:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:20898:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:20898:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:20899:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__NameAssignment_0"


    // $ANTLR start "rule__ParameterCS__OwnedTypeAssignment_1_1"
    // InternalQVTbase.g:20908:1: rule__ParameterCS__OwnedTypeAssignment_1_1 : ( ruleTypedMultiplicityRefCS ) ;
    public final void rule__ParameterCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20912:1: ( ( ruleTypedMultiplicityRefCS ) )
            // InternalQVTbase.g:20913:1: ( ruleTypedMultiplicityRefCS )
            {
            // InternalQVTbase.g:20913:1: ( ruleTypedMultiplicityRefCS )
            // InternalQVTbase.g:20914:1: ruleTypedMultiplicityRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedMultiplicityRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__ParameterCS__QualifiersAssignment_2_1_0_0"
    // InternalQVTbase.g:20923:1: rule__ParameterCS__QualifiersAssignment_2_1_0_0 : ( ( 'ordered' ) ) ;
    public final void rule__ParameterCS__QualifiersAssignment_2_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20927:1: ( ( ( 'ordered' ) ) )
            // InternalQVTbase.g:20928:1: ( ( 'ordered' ) )
            {
            // InternalQVTbase.g:20928:1: ( ( 'ordered' ) )
            // InternalQVTbase.g:20929:1: ( 'ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_0_0());
            }
            // InternalQVTbase.g:20930:1: ( 'ordered' )
            // InternalQVTbase.g:20931:1: 'ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_0_0());
            }
            match(input,105,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__QualifiersAssignment_2_1_0_0"


    // $ANTLR start "rule__ParameterCS__QualifiersAssignment_2_1_0_1"
    // InternalQVTbase.g:20946:1: rule__ParameterCS__QualifiersAssignment_2_1_0_1 : ( ( '!ordered' ) ) ;
    public final void rule__ParameterCS__QualifiersAssignment_2_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20950:1: ( ( ( '!ordered' ) ) )
            // InternalQVTbase.g:20951:1: ( ( '!ordered' ) )
            {
            // InternalQVTbase.g:20951:1: ( ( '!ordered' ) )
            // InternalQVTbase.g:20952:1: ( '!ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_1_0());
            }
            // InternalQVTbase.g:20953:1: ( '!ordered' )
            // InternalQVTbase.g:20954:1: '!ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_1_0());
            }
            match(input,106,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersOrderedKeyword_2_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__QualifiersAssignment_2_1_0_1"


    // $ANTLR start "rule__ParameterCS__QualifiersAssignment_2_1_0_2"
    // InternalQVTbase.g:20969:1: rule__ParameterCS__QualifiersAssignment_2_1_0_2 : ( ( 'unique' ) ) ;
    public final void rule__ParameterCS__QualifiersAssignment_2_1_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20973:1: ( ( ( 'unique' ) ) )
            // InternalQVTbase.g:20974:1: ( ( 'unique' ) )
            {
            // InternalQVTbase.g:20974:1: ( ( 'unique' ) )
            // InternalQVTbase.g:20975:1: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_2_0());
            }
            // InternalQVTbase.g:20976:1: ( 'unique' )
            // InternalQVTbase.g:20977:1: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_2_0());
            }
            match(input,111,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_2_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__QualifiersAssignment_2_1_0_2"


    // $ANTLR start "rule__ParameterCS__QualifiersAssignment_2_1_0_3"
    // InternalQVTbase.g:20992:1: rule__ParameterCS__QualifiersAssignment_2_1_0_3 : ( ( '!unique' ) ) ;
    public final void rule__ParameterCS__QualifiersAssignment_2_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:20996:1: ( ( ( '!unique' ) ) )
            // InternalQVTbase.g:20997:1: ( ( '!unique' ) )
            {
            // InternalQVTbase.g:20997:1: ( ( '!unique' ) )
            // InternalQVTbase.g:20998:1: ( '!unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_3_0());
            }
            // InternalQVTbase.g:20999:1: ( '!unique' )
            // InternalQVTbase.g:21000:1: '!unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_3_0());
            }
            match(input,112,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_3_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getParameterCSAccess().getQualifiersUniqueKeyword_2_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ParameterCS__QualifiersAssignment_2_1_0_3"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_0_0_0"
    // InternalQVTbase.g:21015:1: rule__ReferenceCS__QualifiersAssignment_0_0_0 : ( ( 'static' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_0_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21019:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:21020:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:21020:1: ( ( 'static' ) )
            // InternalQVTbase.g:21021:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            // InternalQVTbase.g:21022:1: ( 'static' )
            // InternalQVTbase.g:21023:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_0_0_0"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_0_0_1"
    // InternalQVTbase.g:21038:1: rule__ReferenceCS__QualifiersAssignment_0_0_1 : ( ( 'definition' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_0_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21042:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:21043:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:21043:1: ( ( 'definition' ) )
            // InternalQVTbase.g:21044:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            // InternalQVTbase.g:21045:1: ( 'definition' )
            // InternalQVTbase.g:21046:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_0_0_1"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_0_1_0"
    // InternalQVTbase.g:21061:1: rule__ReferenceCS__QualifiersAssignment_0_1_0 : ( ( 'definition' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21065:1: ( ( ( 'definition' ) ) )
            // InternalQVTbase.g:21066:1: ( ( 'definition' ) )
            {
            // InternalQVTbase.g:21066:1: ( ( 'definition' ) )
            // InternalQVTbase.g:21067:1: ( 'definition' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            // InternalQVTbase.g:21068:1: ( 'definition' )
            // InternalQVTbase.g:21069:1: 'definition'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }
            match(input,100,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDefinitionKeyword_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_0_1_0"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_0_1_1"
    // InternalQVTbase.g:21084:1: rule__ReferenceCS__QualifiersAssignment_0_1_1 : ( ( 'static' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21088:1: ( ( ( 'static' ) ) )
            // InternalQVTbase.g:21089:1: ( ( 'static' ) )
            {
            // InternalQVTbase.g:21089:1: ( ( 'static' ) )
            // InternalQVTbase.g:21090:1: ( 'static' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            // InternalQVTbase.g:21091:1: ( 'static' )
            // InternalQVTbase.g:21092:1: 'static'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }
            match(input,99,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersStaticKeyword_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_0_1_1"


    // $ANTLR start "rule__ReferenceCS__NameAssignment_2"
    // InternalQVTbase.g:21107:1: rule__ReferenceCS__NameAssignment_2 : ( ruleUnrestrictedName ) ;
    public final void rule__ReferenceCS__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21111:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21112:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:21112:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21113:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__NameAssignment_2"


    // $ANTLR start "rule__ReferenceCS__ReferredOppositeAssignment_3_1"
    // InternalQVTbase.g:21122:1: rule__ReferenceCS__ReferredOppositeAssignment_3_1 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__ReferenceCS__ReferredOppositeAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21126:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21127:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21127:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21128:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getReferredOppositePropertyCrossReference_3_1_0());
            }
            // InternalQVTbase.g:21129:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21130:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getReferredOppositePropertyUnrestrictedNameParserRuleCall_3_1_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getReferredOppositePropertyUnrestrictedNameParserRuleCall_3_1_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getReferredOppositePropertyCrossReference_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__ReferredOppositeAssignment_3_1"


    // $ANTLR start "rule__ReferenceCS__OwnedTypeAssignment_4_1"
    // InternalQVTbase.g:21141:1: rule__ReferenceCS__OwnedTypeAssignment_4_1 : ( ruleTypedMultiplicityRefCS ) ;
    public final void rule__ReferenceCS__OwnedTypeAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21145:1: ( ( ruleTypedMultiplicityRefCS ) )
            // InternalQVTbase.g:21146:1: ( ruleTypedMultiplicityRefCS )
            {
            // InternalQVTbase.g:21146:1: ( ruleTypedMultiplicityRefCS )
            // InternalQVTbase.g:21147:1: ruleTypedMultiplicityRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_4_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedMultiplicityRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedTypeTypedMultiplicityRefCSParserRuleCall_4_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__OwnedTypeAssignment_4_1"


    // $ANTLR start "rule__ReferenceCS__DefaultAssignment_5_1"
    // InternalQVTbase.g:21156:1: rule__ReferenceCS__DefaultAssignment_5_1 : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void rule__ReferenceCS__DefaultAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21160:1: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:21161:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:21161:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:21162:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getDefaultSINGLE_QUOTED_STRINGTerminalRuleCall_5_1_0());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getDefaultSINGLE_QUOTED_STRINGTerminalRuleCall_5_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__DefaultAssignment_5_1"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_0"
    // InternalQVTbase.g:21171:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_0 : ( ( 'composes' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21175:1: ( ( ( 'composes' ) ) )
            // InternalQVTbase.g:21176:1: ( ( 'composes' ) )
            {
            // InternalQVTbase.g:21176:1: ( ( 'composes' ) )
            // InternalQVTbase.g:21177:1: ( 'composes' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_0_0());
            }
            // InternalQVTbase.g:21178:1: ( 'composes' )
            // InternalQVTbase.g:21179:1: 'composes'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_0_0());
            }
            match(input,119,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_0"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_1"
    // InternalQVTbase.g:21194:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_1 : ( ( '!composes' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21198:1: ( ( ( '!composes' ) ) )
            // InternalQVTbase.g:21199:1: ( ( '!composes' ) )
            {
            // InternalQVTbase.g:21199:1: ( ( '!composes' ) )
            // InternalQVTbase.g:21200:1: ( '!composes' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_1_0());
            }
            // InternalQVTbase.g:21201:1: ( '!composes' )
            // InternalQVTbase.g:21202:1: '!composes'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_1_0());
            }
            match(input,120,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersComposesKeyword_6_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_1"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_2"
    // InternalQVTbase.g:21217:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_2 : ( ( 'derived' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21221:1: ( ( ( 'derived' ) ) )
            // InternalQVTbase.g:21222:1: ( ( 'derived' ) )
            {
            // InternalQVTbase.g:21222:1: ( ( 'derived' ) )
            // InternalQVTbase.g:21223:1: ( 'derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_2_0());
            }
            // InternalQVTbase.g:21224:1: ( 'derived' )
            // InternalQVTbase.g:21225:1: 'derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_2_0());
            }
            match(input,101,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_2_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_2"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_3"
    // InternalQVTbase.g:21240:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_3 : ( ( '!derived' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21244:1: ( ( ( '!derived' ) ) )
            // InternalQVTbase.g:21245:1: ( ( '!derived' ) )
            {
            // InternalQVTbase.g:21245:1: ( ( '!derived' ) )
            // InternalQVTbase.g:21246:1: ( '!derived' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_3_0());
            }
            // InternalQVTbase.g:21247:1: ( '!derived' )
            // InternalQVTbase.g:21248:1: '!derived'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_3_0());
            }
            match(input,102,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_3_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersDerivedKeyword_6_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_3"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_4"
    // InternalQVTbase.g:21263:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_4 : ( ( 'ordered' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21267:1: ( ( ( 'ordered' ) ) )
            // InternalQVTbase.g:21268:1: ( ( 'ordered' ) )
            {
            // InternalQVTbase.g:21268:1: ( ( 'ordered' ) )
            // InternalQVTbase.g:21269:1: ( 'ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_4_0());
            }
            // InternalQVTbase.g:21270:1: ( 'ordered' )
            // InternalQVTbase.g:21271:1: 'ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_4_0());
            }
            match(input,105,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_4_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_4"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_5"
    // InternalQVTbase.g:21286:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_5 : ( ( '!ordered' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_5() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21290:1: ( ( ( '!ordered' ) ) )
            // InternalQVTbase.g:21291:1: ( ( '!ordered' ) )
            {
            // InternalQVTbase.g:21291:1: ( ( '!ordered' ) )
            // InternalQVTbase.g:21292:1: ( '!ordered' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_5_0());
            }
            // InternalQVTbase.g:21293:1: ( '!ordered' )
            // InternalQVTbase.g:21294:1: '!ordered'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_5_0());
            }
            match(input,106,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_5_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersOrderedKeyword_6_1_0_5_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_5"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_6"
    // InternalQVTbase.g:21309:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_6 : ( ( 'readonly' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21313:1: ( ( ( 'readonly' ) ) )
            // InternalQVTbase.g:21314:1: ( ( 'readonly' ) )
            {
            // InternalQVTbase.g:21314:1: ( ( 'readonly' ) )
            // InternalQVTbase.g:21315:1: ( 'readonly' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_6_0());
            }
            // InternalQVTbase.g:21316:1: ( 'readonly' )
            // InternalQVTbase.g:21317:1: 'readonly'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_6_0());
            }
            match(input,107,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_6_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_6"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_7"
    // InternalQVTbase.g:21332:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_7 : ( ( '!readonly' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_7() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21336:1: ( ( ( '!readonly' ) ) )
            // InternalQVTbase.g:21337:1: ( ( '!readonly' ) )
            {
            // InternalQVTbase.g:21337:1: ( ( '!readonly' ) )
            // InternalQVTbase.g:21338:1: ( '!readonly' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_7_0());
            }
            // InternalQVTbase.g:21339:1: ( '!readonly' )
            // InternalQVTbase.g:21340:1: '!readonly'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_7_0());
            }
            match(input,108,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_7_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersReadonlyKeyword_6_1_0_7_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_7"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_8"
    // InternalQVTbase.g:21355:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_8 : ( ( 'resolve' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_8() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21359:1: ( ( ( 'resolve' ) ) )
            // InternalQVTbase.g:21360:1: ( ( 'resolve' ) )
            {
            // InternalQVTbase.g:21360:1: ( ( 'resolve' ) )
            // InternalQVTbase.g:21361:1: ( 'resolve' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_8_0());
            }
            // InternalQVTbase.g:21362:1: ( 'resolve' )
            // InternalQVTbase.g:21363:1: 'resolve'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_8_0());
            }
            match(input,121,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_8_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_8_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_8"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_9"
    // InternalQVTbase.g:21378:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_9 : ( ( '!resolve' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_9() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21382:1: ( ( ( '!resolve' ) ) )
            // InternalQVTbase.g:21383:1: ( ( '!resolve' ) )
            {
            // InternalQVTbase.g:21383:1: ( ( '!resolve' ) )
            // InternalQVTbase.g:21384:1: ( '!resolve' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_9_0());
            }
            // InternalQVTbase.g:21385:1: ( '!resolve' )
            // InternalQVTbase.g:21386:1: '!resolve'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_9_0());
            }
            match(input,122,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_9_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersResolveKeyword_6_1_0_9_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_9"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_10"
    // InternalQVTbase.g:21401:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_10 : ( ( 'transient' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_10() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21405:1: ( ( ( 'transient' ) ) )
            // InternalQVTbase.g:21406:1: ( ( 'transient' ) )
            {
            // InternalQVTbase.g:21406:1: ( ( 'transient' ) )
            // InternalQVTbase.g:21407:1: ( 'transient' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_10_0());
            }
            // InternalQVTbase.g:21408:1: ( 'transient' )
            // InternalQVTbase.g:21409:1: 'transient'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_10_0());
            }
            match(input,109,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_10_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_10_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_10"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_11"
    // InternalQVTbase.g:21424:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_11 : ( ( '!transient' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_11() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21428:1: ( ( ( '!transient' ) ) )
            // InternalQVTbase.g:21429:1: ( ( '!transient' ) )
            {
            // InternalQVTbase.g:21429:1: ( ( '!transient' ) )
            // InternalQVTbase.g:21430:1: ( '!transient' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_11_0());
            }
            // InternalQVTbase.g:21431:1: ( '!transient' )
            // InternalQVTbase.g:21432:1: '!transient'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_11_0());
            }
            match(input,110,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_11_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersTransientKeyword_6_1_0_11_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_11"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_12"
    // InternalQVTbase.g:21447:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_12 : ( ( 'unique' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_12() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21451:1: ( ( ( 'unique' ) ) )
            // InternalQVTbase.g:21452:1: ( ( 'unique' ) )
            {
            // InternalQVTbase.g:21452:1: ( ( 'unique' ) )
            // InternalQVTbase.g:21453:1: ( 'unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_12_0());
            }
            // InternalQVTbase.g:21454:1: ( 'unique' )
            // InternalQVTbase.g:21455:1: 'unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_12_0());
            }
            match(input,111,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_12_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_12_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_12"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_13"
    // InternalQVTbase.g:21470:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_13 : ( ( '!unique' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_13() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21474:1: ( ( ( '!unique' ) ) )
            // InternalQVTbase.g:21475:1: ( ( '!unique' ) )
            {
            // InternalQVTbase.g:21475:1: ( ( '!unique' ) )
            // InternalQVTbase.g:21476:1: ( '!unique' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_13_0());
            }
            // InternalQVTbase.g:21477:1: ( '!unique' )
            // InternalQVTbase.g:21478:1: '!unique'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_13_0());
            }
            match(input,112,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_13_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUniqueKeyword_6_1_0_13_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_13"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_14"
    // InternalQVTbase.g:21493:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_14 : ( ( 'unsettable' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_14() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21497:1: ( ( ( 'unsettable' ) ) )
            // InternalQVTbase.g:21498:1: ( ( 'unsettable' ) )
            {
            // InternalQVTbase.g:21498:1: ( ( 'unsettable' ) )
            // InternalQVTbase.g:21499:1: ( 'unsettable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_14_0());
            }
            // InternalQVTbase.g:21500:1: ( 'unsettable' )
            // InternalQVTbase.g:21501:1: 'unsettable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_14_0());
            }
            match(input,113,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_14_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_14_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_14"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_15"
    // InternalQVTbase.g:21516:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_15 : ( ( '!unsettable' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_15() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21520:1: ( ( ( '!unsettable' ) ) )
            // InternalQVTbase.g:21521:1: ( ( '!unsettable' ) )
            {
            // InternalQVTbase.g:21521:1: ( ( '!unsettable' ) )
            // InternalQVTbase.g:21522:1: ( '!unsettable' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_15_0());
            }
            // InternalQVTbase.g:21523:1: ( '!unsettable' )
            // InternalQVTbase.g:21524:1: '!unsettable'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_15_0());
            }
            match(input,114,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_15_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersUnsettableKeyword_6_1_0_15_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_15"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_16"
    // InternalQVTbase.g:21539:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_16 : ( ( 'volatile' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_16() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21543:1: ( ( ( 'volatile' ) ) )
            // InternalQVTbase.g:21544:1: ( ( 'volatile' ) )
            {
            // InternalQVTbase.g:21544:1: ( ( 'volatile' ) )
            // InternalQVTbase.g:21545:1: ( 'volatile' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_16_0());
            }
            // InternalQVTbase.g:21546:1: ( 'volatile' )
            // InternalQVTbase.g:21547:1: 'volatile'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_16_0());
            }
            match(input,115,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_16_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_16_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_16"


    // $ANTLR start "rule__ReferenceCS__QualifiersAssignment_6_1_0_17"
    // InternalQVTbase.g:21562:1: rule__ReferenceCS__QualifiersAssignment_6_1_0_17 : ( ( '!volatile' ) ) ;
    public final void rule__ReferenceCS__QualifiersAssignment_6_1_0_17() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21566:1: ( ( ( '!volatile' ) ) )
            // InternalQVTbase.g:21567:1: ( ( '!volatile' ) )
            {
            // InternalQVTbase.g:21567:1: ( ( '!volatile' ) )
            // InternalQVTbase.g:21568:1: ( '!volatile' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_17_0());
            }
            // InternalQVTbase.g:21569:1: ( '!volatile' )
            // InternalQVTbase.g:21570:1: '!volatile'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_17_0());
            }
            match(input,116,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_17_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getQualifiersVolatileKeyword_6_1_0_17_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__QualifiersAssignment_6_1_0_17"


    // $ANTLR start "rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3"
    // InternalQVTbase.g:21585:1: rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3 : ( ruleSpecificationCS ) ;
    public final void rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21589:1: ( ( ruleSpecificationCS ) )
            // InternalQVTbase.g:21590:1: ( ruleSpecificationCS )
            {
            // InternalQVTbase.g:21590:1: ( ruleSpecificationCS )
            // InternalQVTbase.g:21591:1: ruleSpecificationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_7_0_1_0_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSpecificationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_7_0_1_0_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_0_3"


    // $ANTLR start "rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3"
    // InternalQVTbase.g:21600:1: rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3 : ( ruleSpecificationCS ) ;
    public final void rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21604:1: ( ( ruleSpecificationCS ) )
            // InternalQVTbase.g:21605:1: ( ruleSpecificationCS )
            {
            // InternalQVTbase.g:21605:1: ( ruleSpecificationCS )
            // InternalQVTbase.g:21606:1: ruleSpecificationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_7_0_1_1_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSpecificationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getReferenceCSAccess().getOwnedDefaultExpressionsSpecificationCSParserRuleCall_7_0_1_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ReferenceCS__OwnedDefaultExpressionsAssignment_7_0_1_1_3"


    // $ANTLR start "rule__SimpleTargetElementCS__InputAssignment_0_0"
    // InternalQVTbase.g:21615:1: rule__SimpleTargetElementCS__InputAssignment_0_0 : ( ( 'input' ) ) ;
    public final void rule__SimpleTargetElementCS__InputAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21619:1: ( ( ( 'input' ) ) )
            // InternalQVTbase.g:21620:1: ( ( 'input' ) )
            {
            // InternalQVTbase.g:21620:1: ( ( 'input' ) )
            // InternalQVTbase.g:21621:1: ( 'input' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getInputInputKeyword_0_0_0());
            }
            // InternalQVTbase.g:21622:1: ( 'input' )
            // InternalQVTbase.g:21623:1: 'input'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getInputInputKeyword_0_0_0());
            }
            match(input,123,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getInputInputKeyword_0_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getInputInputKeyword_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__InputAssignment_0_0"


    // $ANTLR start "rule__SimpleTargetElementCS__OutputAssignment_0_1"
    // InternalQVTbase.g:21638:1: rule__SimpleTargetElementCS__OutputAssignment_0_1 : ( ( 'output' ) ) ;
    public final void rule__SimpleTargetElementCS__OutputAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21642:1: ( ( ( 'output' ) ) )
            // InternalQVTbase.g:21643:1: ( ( 'output' ) )
            {
            // InternalQVTbase.g:21643:1: ( ( 'output' ) )
            // InternalQVTbase.g:21644:1: ( 'output' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getOutputOutputKeyword_0_1_0());
            }
            // InternalQVTbase.g:21645:1: ( 'output' )
            // InternalQVTbase.g:21646:1: 'output'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getOutputOutputKeyword_0_1_0());
            }
            match(input,124,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getOutputOutputKeyword_0_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getOutputOutputKeyword_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__OutputAssignment_0_1"


    // $ANTLR start "rule__SimpleTargetElementCS__ViaAssignment_0_2"
    // InternalQVTbase.g:21661:1: rule__SimpleTargetElementCS__ViaAssignment_0_2 : ( ( 'via' ) ) ;
    public final void rule__SimpleTargetElementCS__ViaAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21665:1: ( ( ( 'via' ) ) )
            // InternalQVTbase.g:21666:1: ( ( 'via' ) )
            {
            // InternalQVTbase.g:21666:1: ( ( 'via' ) )
            // InternalQVTbase.g:21667:1: ( 'via' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getViaViaKeyword_0_2_0());
            }
            // InternalQVTbase.g:21668:1: ( 'via' )
            // InternalQVTbase.g:21669:1: 'via'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getViaViaKeyword_0_2_0());
            }
            match(input,125,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getViaViaKeyword_0_2_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getViaViaKeyword_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__ViaAssignment_0_2"


    // $ANTLR start "rule__SimpleTargetElementCS__TypedModelAssignment_1"
    // InternalQVTbase.g:21684:1: rule__SimpleTargetElementCS__TypedModelAssignment_1 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__SimpleTargetElementCS__TypedModelAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21688:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21689:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21689:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21690:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelTypedModelCrossReference_1_0());
            }
            // InternalQVTbase.g:21691:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21692:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelTypedModelUnrestrictedNameParserRuleCall_1_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelTypedModelUnrestrictedNameParserRuleCall_1_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getTypedModelTypedModelCrossReference_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__TypedModelAssignment_1"


    // $ANTLR start "rule__SimpleTargetElementCS__IteratesAssignment_2_1_0"
    // InternalQVTbase.g:21703:1: rule__SimpleTargetElementCS__IteratesAssignment_2_1_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__SimpleTargetElementCS__IteratesAssignment_2_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21707:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21708:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21708:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21709:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_0_0());
            }
            // InternalQVTbase.g:21710:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21711:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__IteratesAssignment_2_1_0"


    // $ANTLR start "rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0"
    // InternalQVTbase.g:21722:1: rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21726:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21727:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21727:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21728:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_1_1_0_0());
            }
            // InternalQVTbase.g:21729:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21730:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_1_1_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_1_1_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_1_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_0"


    // $ANTLR start "rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1"
    // InternalQVTbase.g:21741:1: rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21745:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21746:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21746:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21747:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_1_1_1_1_0());
            }
            // InternalQVTbase.g:21748:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21749:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_1_1_1_1_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelUnrestrictedNameParserRuleCall_2_1_1_1_1_1_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getSimpleTargetElementCSAccess().getIteratesTypedModelCrossReference_2_1_1_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SimpleTargetElementCS__IteratesAssignment_2_1_1_1_1_1"


    // $ANTLR start "rule__SpecificationCS__OwnedExpressionAssignment_0"
    // InternalQVTbase.g:21760:1: rule__SpecificationCS__OwnedExpressionAssignment_0 : ( ruleExpCS ) ;
    public final void rule__SpecificationCS__OwnedExpressionAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21764:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:21765:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:21765:1: ( ruleExpCS )
            // InternalQVTbase.g:21766:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSpecificationCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSpecificationCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SpecificationCS__OwnedExpressionAssignment_0"


    // $ANTLR start "rule__SpecificationCS__ExprStringAssignment_1"
    // InternalQVTbase.g:21775:1: rule__SpecificationCS__ExprStringAssignment_1 : ( RULE_UNQUOTED_STRING ) ;
    public final void rule__SpecificationCS__ExprStringAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21779:1: ( ( RULE_UNQUOTED_STRING ) )
            // InternalQVTbase.g:21780:1: ( RULE_UNQUOTED_STRING )
            {
            // InternalQVTbase.g:21780:1: ( RULE_UNQUOTED_STRING )
            // InternalQVTbase.g:21781:1: RULE_UNQUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSpecificationCSAccess().getExprStringUNQUOTED_STRINGTerminalRuleCall_1_0());
            }
            match(input,RULE_UNQUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSpecificationCSAccess().getExprStringUNQUOTED_STRINGTerminalRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SpecificationCS__ExprStringAssignment_1"


    // $ANTLR start "rule__StructuredClassCS__IsAbstractAssignment_0"
    // InternalQVTbase.g:21790:1: rule__StructuredClassCS__IsAbstractAssignment_0 : ( ( 'abstract' ) ) ;
    public final void rule__StructuredClassCS__IsAbstractAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21794:1: ( ( ( 'abstract' ) ) )
            // InternalQVTbase.g:21795:1: ( ( 'abstract' ) )
            {
            // InternalQVTbase.g:21795:1: ( ( 'abstract' ) )
            // InternalQVTbase.g:21796:1: ( 'abstract' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsAbstractAbstractKeyword_0_0());
            }
            // InternalQVTbase.g:21797:1: ( 'abstract' )
            // InternalQVTbase.g:21798:1: 'abstract'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsAbstractAbstractKeyword_0_0());
            }
            match(input,126,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsAbstractAbstractKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsAbstractAbstractKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__IsAbstractAssignment_0"


    // $ANTLR start "rule__StructuredClassCS__NameAssignment_2"
    // InternalQVTbase.g:21813:1: rule__StructuredClassCS__NameAssignment_2 : ( ruleUnrestrictedName ) ;
    public final void rule__StructuredClassCS__NameAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21817:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21818:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:21818:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21819:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getNameUnrestrictedNameParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__NameAssignment_2"


    // $ANTLR start "rule__StructuredClassCS__OwnedSignatureAssignment_3"
    // InternalQVTbase.g:21828:1: rule__StructuredClassCS__OwnedSignatureAssignment_3 : ( ruleTemplateSignatureCS ) ;
    public final void rule__StructuredClassCS__OwnedSignatureAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21832:1: ( ( ruleTemplateSignatureCS ) )
            // InternalQVTbase.g:21833:1: ( ruleTemplateSignatureCS )
            {
            // InternalQVTbase.g:21833:1: ( ruleTemplateSignatureCS )
            // InternalQVTbase.g:21834:1: ruleTemplateSignatureCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateSignatureCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSignatureTemplateSignatureCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__OwnedSignatureAssignment_3"


    // $ANTLR start "rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1"
    // InternalQVTbase.g:21843:1: rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1 : ( ruleTypedRefCS ) ;
    public final void rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21847:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:21848:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:21848:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:21849:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesTypedRefCSParserRuleCall_4_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesTypedRefCSParserRuleCall_4_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__OwnedSuperTypesAssignment_4_1"


    // $ANTLR start "rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1"
    // InternalQVTbase.g:21858:1: rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21862:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:21863:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:21863:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:21864:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesTypedRefCSParserRuleCall_4_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedSuperTypesTypedRefCSParserRuleCall_4_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__OwnedSuperTypesAssignment_4_2_1"


    // $ANTLR start "rule__StructuredClassCS__InstanceClassNameAssignment_5_1"
    // InternalQVTbase.g:21873:1: rule__StructuredClassCS__InstanceClassNameAssignment_5_1 : ( RULE_SINGLE_QUOTED_STRING ) ;
    public final void rule__StructuredClassCS__InstanceClassNameAssignment_5_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21877:1: ( ( RULE_SINGLE_QUOTED_STRING ) )
            // InternalQVTbase.g:21878:1: ( RULE_SINGLE_QUOTED_STRING )
            {
            // InternalQVTbase.g:21878:1: ( RULE_SINGLE_QUOTED_STRING )
            // InternalQVTbase.g:21879:1: RULE_SINGLE_QUOTED_STRING
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_5_1_0());
            }
            match(input,RULE_SINGLE_QUOTED_STRING,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getInstanceClassNameSINGLE_QUOTED_STRINGTerminalRuleCall_5_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__InstanceClassNameAssignment_5_1"


    // $ANTLR start "rule__StructuredClassCS__IsInterfaceAssignment_6_1"
    // InternalQVTbase.g:21888:1: rule__StructuredClassCS__IsInterfaceAssignment_6_1 : ( ( 'interface' ) ) ;
    public final void rule__StructuredClassCS__IsInterfaceAssignment_6_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21892:1: ( ( ( 'interface' ) ) )
            // InternalQVTbase.g:21893:1: ( ( 'interface' ) )
            {
            // InternalQVTbase.g:21893:1: ( ( 'interface' ) )
            // InternalQVTbase.g:21894:1: ( 'interface' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsInterfaceInterfaceKeyword_6_1_0());
            }
            // InternalQVTbase.g:21895:1: ( 'interface' )
            // InternalQVTbase.g:21896:1: 'interface'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getIsInterfaceInterfaceKeyword_6_1_0());
            }
            match(input,127,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsInterfaceInterfaceKeyword_6_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getIsInterfaceInterfaceKeyword_6_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__IsInterfaceAssignment_6_1"


    // $ANTLR start "rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0"
    // InternalQVTbase.g:21911:1: rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0 : ( ruleOperationCS ) ;
    public final void rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21915:1: ( ( ruleOperationCS ) )
            // InternalQVTbase.g:21916:1: ( ruleOperationCS )
            {
            // InternalQVTbase.g:21916:1: ( ruleOperationCS )
            // InternalQVTbase.g:21917:1: ruleOperationCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedOperationsOperationCSParserRuleCall_7_0_1_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleOperationCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedOperationsOperationCSParserRuleCall_7_0_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__OwnedOperationsAssignment_7_0_1_0"


    // $ANTLR start "rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1"
    // InternalQVTbase.g:21926:1: rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1 : ( ruleStructuralFeatureCS ) ;
    public final void rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21930:1: ( ( ruleStructuralFeatureCS ) )
            // InternalQVTbase.g:21931:1: ( ruleStructuralFeatureCS )
            {
            // InternalQVTbase.g:21931:1: ( ruleStructuralFeatureCS )
            // InternalQVTbase.g:21932:1: ruleStructuralFeatureCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStructuredClassCSAccess().getOwnedPropertiesStructuralFeatureCSParserRuleCall_7_0_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleStructuralFeatureCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStructuredClassCSAccess().getOwnedPropertiesStructuralFeatureCSParserRuleCall_7_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StructuredClassCS__OwnedPropertiesAssignment_7_0_1_1"


    // $ANTLR start "rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1"
    // InternalQVTbase.g:21943:1: rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21947:1: ( ( ruleMultiplicityCS ) )
            // InternalQVTbase.g:21948:1: ( ruleMultiplicityCS )
            {
            // InternalQVTbase.g:21948:1: ( ruleMultiplicityCS )
            // InternalQVTbase.g:21949:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedMultiplicityRefCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedMultiplicityRefCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedMultiplicityRefCS__OwnedMultiplicityAssignment_1"


    // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_0"
    // InternalQVTbase.g:21961:1: rule__URIFirstPathElementCS__ReferredElementAssignment_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21965:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:21966:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:21966:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:21967:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0());
            }
            // InternalQVTbase.g:21968:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:21969:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_0"


    // $ANTLR start "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1"
    // InternalQVTbase.g:21980:1: rule__URIFirstPathElementCS__ReferredElementAssignment_1_1 : ( ( ruleURI ) ) ;
    public final void rule__URIFirstPathElementCS__ReferredElementAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:21984:1: ( ( ( ruleURI ) ) )
            // InternalQVTbase.g:21985:1: ( ( ruleURI ) )
            {
            // InternalQVTbase.g:21985:1: ( ( ruleURI ) )
            // InternalQVTbase.g:21986:1: ( ruleURI )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0());
            }
            // InternalQVTbase.g:21987:1: ( ruleURI )
            // InternalQVTbase.g:21988:1: ruleURI
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleURI();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceURIParserRuleCall_1_1_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getURIFirstPathElementCSAccess().getReferredElementNamespaceCrossReference_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__URIFirstPathElementCS__ReferredElementAssignment_1_1"


    // $ANTLR start "rule__PrimitiveTypeCS__NameAssignment"
    // InternalQVTbase.g:22000:1: rule__PrimitiveTypeCS__NameAssignment : ( rulePrimitiveTypeIdentifier ) ;
    public final void rule__PrimitiveTypeCS__NameAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22004:1: ( ( rulePrimitiveTypeIdentifier ) )
            // InternalQVTbase.g:22005:1: ( rulePrimitiveTypeIdentifier )
            {
            // InternalQVTbase.g:22005:1: ( rulePrimitiveTypeIdentifier )
            // InternalQVTbase.g:22006:1: rulePrimitiveTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrimitiveTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrimitiveTypeCSAccess().getNamePrimitiveTypeIdentifierParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrimitiveTypeCS__NameAssignment"


    // $ANTLR start "rule__CollectionTypeCS__NameAssignment_0"
    // InternalQVTbase.g:22015:1: rule__CollectionTypeCS__NameAssignment_0 : ( ruleCollectionTypeIdentifier ) ;
    public final void rule__CollectionTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22019:1: ( ( ruleCollectionTypeIdentifier ) )
            // InternalQVTbase.g:22020:1: ( ruleCollectionTypeIdentifier )
            {
            // InternalQVTbase.g:22020:1: ( ruleCollectionTypeIdentifier )
            // InternalQVTbase.g:22021:1: ruleCollectionTypeIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getNameCollectionTypeIdentifierParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__NameAssignment_0"


    // $ANTLR start "rule__CollectionTypeCS__OwnedTypeAssignment_1_1"
    // InternalQVTbase.g:22030:1: rule__CollectionTypeCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpWithoutMultiplicityCS ) ;
    public final void rule__CollectionTypeCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22034:1: ( ( ruleTypeExpWithoutMultiplicityCS ) )
            // InternalQVTbase.g:22035:1: ( ruleTypeExpWithoutMultiplicityCS )
            {
            // InternalQVTbase.g:22035:1: ( ruleTypeExpWithoutMultiplicityCS )
            // InternalQVTbase.g:22036:1: ruleTypeExpWithoutMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpWithoutMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedTypeTypeExpWithoutMultiplicityCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2"
    // InternalQVTbase.g:22045:1: rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2 : ( ruleMultiplicityCS ) ;
    public final void rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22049:1: ( ( ruleMultiplicityCS ) )
            // InternalQVTbase.g:22050:1: ( ruleMultiplicityCS )
            {
            // InternalQVTbase.g:22050:1: ( ruleMultiplicityCS )
            // InternalQVTbase.g:22051:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionTypeCSAccess().getOwnedCollectionMultiplicityMultiplicityCSParserRuleCall_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionTypeCS__OwnedCollectionMultiplicityAssignment_1_2"


    // $ANTLR start "rule__MapTypeCS__NameAssignment_0"
    // InternalQVTbase.g:22060:1: rule__MapTypeCS__NameAssignment_0 : ( ( 'Map' ) ) ;
    public final void rule__MapTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22064:1: ( ( ( 'Map' ) ) )
            // InternalQVTbase.g:22065:1: ( ( 'Map' ) )
            {
            // InternalQVTbase.g:22065:1: ( ( 'Map' ) )
            // InternalQVTbase.g:22066:1: ( 'Map' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }
            // InternalQVTbase.g:22067:1: ( 'Map' )
            // InternalQVTbase.g:22068:1: 'Map'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }
            match(input,43,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getNameMapKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__NameAssignment_0"


    // $ANTLR start "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1"
    // InternalQVTbase.g:22083:1: rule__MapTypeCS__OwnedKeyTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedKeyTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22087:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:22088:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:22088:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:22089:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedKeyTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__OwnedKeyTypeAssignment_1_1"


    // $ANTLR start "rule__MapTypeCS__OwnedValueTypeAssignment_1_3"
    // InternalQVTbase.g:22098:1: rule__MapTypeCS__OwnedValueTypeAssignment_1_3 : ( ruleTypeExpCS ) ;
    public final void rule__MapTypeCS__OwnedValueTypeAssignment_1_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22102:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:22103:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:22103:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:22104:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapTypeCSAccess().getOwnedValueTypeTypeExpCSParserRuleCall_1_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapTypeCS__OwnedValueTypeAssignment_1_3"


    // $ANTLR start "rule__TupleTypeCS__NameAssignment_0"
    // InternalQVTbase.g:22113:1: rule__TupleTypeCS__NameAssignment_0 : ( ( 'Tuple' ) ) ;
    public final void rule__TupleTypeCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22117:1: ( ( ( 'Tuple' ) ) )
            // InternalQVTbase.g:22118:1: ( ( 'Tuple' ) )
            {
            // InternalQVTbase.g:22118:1: ( ( 'Tuple' ) )
            // InternalQVTbase.g:22119:1: ( 'Tuple' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }
            // InternalQVTbase.g:22120:1: ( 'Tuple' )
            // InternalQVTbase.g:22121:1: 'Tuple'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }
            match(input,44,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getNameTupleKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__NameAssignment_0"


    // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0"
    // InternalQVTbase.g:22136:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_0 : ( ruleTuplePartCS ) ;
    public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22140:1: ( ( ruleTuplePartCS ) )
            // InternalQVTbase.g:22141:1: ( ruleTuplePartCS )
            {
            // InternalQVTbase.g:22141:1: ( ruleTuplePartCS )
            // InternalQVTbase.g:22142:1: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTuplePartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_0"


    // $ANTLR start "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1"
    // InternalQVTbase.g:22151:1: rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1 : ( ruleTuplePartCS ) ;
    public final void rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22155:1: ( ( ruleTuplePartCS ) )
            // InternalQVTbase.g:22156:1: ( ruleTuplePartCS )
            {
            // InternalQVTbase.g:22156:1: ( ruleTuplePartCS )
            // InternalQVTbase.g:22157:1: ruleTuplePartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTuplePartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleTypeCSAccess().getOwnedPartsTuplePartCSParserRuleCall_1_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleTypeCS__OwnedPartsAssignment_1_1_1_1"


    // $ANTLR start "rule__TuplePartCS__NameAssignment_0"
    // InternalQVTbase.g:22166:1: rule__TuplePartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TuplePartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22170:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:22171:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:22171:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:22172:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__NameAssignment_0"


    // $ANTLR start "rule__TuplePartCS__OwnedTypeAssignment_2"
    // InternalQVTbase.g:22181:1: rule__TuplePartCS__OwnedTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__TuplePartCS__OwnedTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22185:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:22186:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:22186:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:22187:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTuplePartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TuplePartCS__OwnedTypeAssignment_2"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0"
    // InternalQVTbase.g:22196:1: rule__CollectionLiteralExpCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22200:1: ( ( ruleCollectionTypeCS ) )
            // InternalQVTbase.g:22201:1: ( ruleCollectionTypeCS )
            {
            // InternalQVTbase.g:22201:1: ( ruleCollectionTypeCS )
            // InternalQVTbase.g:22202:1: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0"
    // InternalQVTbase.g:22211:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22215:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalQVTbase.g:22216:1: ( ruleCollectionLiteralPartCS )
            {
            // InternalQVTbase.g:22216:1: ( ruleCollectionLiteralPartCS )
            // InternalQVTbase.g:22217:1: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1"
    // InternalQVTbase.g:22226:1: rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleCollectionLiteralPartCS ) ;
    public final void rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22230:1: ( ( ruleCollectionLiteralPartCS ) )
            // InternalQVTbase.g:22231:1: ( ruleCollectionLiteralPartCS )
            {
            // InternalQVTbase.g:22231:1: ( ruleCollectionLiteralPartCS )
            // InternalQVTbase.g:22232:1: ruleCollectionLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralExpCSAccess().getOwnedPartsCollectionLiteralPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralExpCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0"
    // InternalQVTbase.g:22241:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22245:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22246:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22246:1: ( ruleExpCS )
            // InternalQVTbase.g:22247:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionExpCSParserRuleCall_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_0_0"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1"
    // InternalQVTbase.g:22256:1: rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1 : ( ruleExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22260:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22261:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22261:1: ( ruleExpCS )
            // InternalQVTbase.g:22262:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedLastExpressionExpCSParserRuleCall_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedLastExpressionAssignment_0_1_1"


    // $ANTLR start "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1"
    // InternalQVTbase.g:22271:1: rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22275:1: ( ( rulePatternExpCS ) )
            // InternalQVTbase.g:22276:1: ( rulePatternExpCS )
            {
            // InternalQVTbase.g:22276:1: ( rulePatternExpCS )
            // InternalQVTbase.g:22277:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionLiteralPartCSAccess().getOwnedExpressionPatternExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionLiteralPartCS__OwnedExpressionAssignment_1"


    // $ANTLR start "rule__CollectionPatternCS__OwnedTypeAssignment_0"
    // InternalQVTbase.g:22286:1: rule__CollectionPatternCS__OwnedTypeAssignment_0 : ( ruleCollectionTypeCS ) ;
    public final void rule__CollectionPatternCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22290:1: ( ( ruleCollectionTypeCS ) )
            // InternalQVTbase.g:22291:1: ( ruleCollectionTypeCS )
            {
            // InternalQVTbase.g:22291:1: ( ruleCollectionTypeCS )
            // InternalQVTbase.g:22292:1: ruleCollectionTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCollectionTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedTypeCollectionTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_0"
    // InternalQVTbase.g:22301:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_0 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22305:1: ( ( rulePatternExpCS ) )
            // InternalQVTbase.g:22306:1: ( rulePatternExpCS )
            {
            // InternalQVTbase.g:22306:1: ( rulePatternExpCS )
            // InternalQVTbase.g:22307:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1"
    // InternalQVTbase.g:22316:1: rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1 : ( rulePatternExpCS ) ;
    public final void rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22320:1: ( ( rulePatternExpCS ) )
            // InternalQVTbase.g:22321:1: ( rulePatternExpCS )
            {
            // InternalQVTbase.g:22321:1: ( rulePatternExpCS )
            // InternalQVTbase.g:22322:1: rulePatternExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePatternExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getOwnedPartsPatternExpCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1"
    // InternalQVTbase.g:22331:1: rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1 : ( ruleIdentifier ) ;
    public final void rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22335:1: ( ( ruleIdentifier ) )
            // InternalQVTbase.g:22336:1: ( ruleIdentifier )
            {
            // InternalQVTbase.g:22336:1: ( ruleIdentifier )
            // InternalQVTbase.g:22337:1: ruleIdentifier
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleIdentifier();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCollectionPatternCSAccess().getRestVariableNameIdentifierParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CollectionPatternCS__RestVariableNameAssignment_2_2_1"


    // $ANTLR start "rule__ShadowPartCS__ReferredPropertyAssignment_0_0"
    // InternalQVTbase.g:22346:1: rule__ShadowPartCS__ReferredPropertyAssignment_0_0 : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__ShadowPartCS__ReferredPropertyAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22350:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:22351:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:22351:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:22352:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0());
            }
            // InternalQVTbase.g:22353:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:22354:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyUnrestrictedNameParserRuleCall_0_0_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getReferredPropertyPropertyCrossReference_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__ReferredPropertyAssignment_0_0"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2"
    // InternalQVTbase.g:22365:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2 : ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) ;
    public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22369:1: ( ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) ) )
            // InternalQVTbase.g:22370:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) )
            {
            // InternalQVTbase.g:22370:1: ( ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 ) )
            // InternalQVTbase.g:22371:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0());
            }
            // InternalQVTbase.g:22372:1: ( rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0 )
            // InternalQVTbase.g:22372:2: rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__ShadowPartCS__OwnedInitExpressionAlternatives_0_2_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionAlternatives_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_0_2"


    // $ANTLR start "rule__ShadowPartCS__OwnedInitExpressionAssignment_1"
    // InternalQVTbase.g:22381:1: rule__ShadowPartCS__OwnedInitExpressionAssignment_1 : ( ruleStringLiteralExpCS ) ;
    public final void rule__ShadowPartCS__OwnedInitExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22385:1: ( ( ruleStringLiteralExpCS ) )
            // InternalQVTbase.g:22386:1: ( ruleStringLiteralExpCS )
            {
            // InternalQVTbase.g:22386:1: ( ruleStringLiteralExpCS )
            // InternalQVTbase.g:22387:1: ruleStringLiteralExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleStringLiteralExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getShadowPartCSAccess().getOwnedInitExpressionStringLiteralExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ShadowPartCS__OwnedInitExpressionAssignment_1"


    // $ANTLR start "rule__PatternExpCS__PatternVariableNameAssignment_0"
    // InternalQVTbase.g:22396:1: rule__PatternExpCS__PatternVariableNameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__PatternExpCS__PatternVariableNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22400:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:22401:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:22401:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:22402:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getPatternVariableNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__PatternVariableNameAssignment_0"


    // $ANTLR start "rule__PatternExpCS__OwnedPatternTypeAssignment_2"
    // InternalQVTbase.g:22411:1: rule__PatternExpCS__OwnedPatternTypeAssignment_2 : ( ruleTypeExpCS ) ;
    public final void rule__PatternExpCS__OwnedPatternTypeAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22415:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:22416:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:22416:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:22417:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPatternExpCSAccess().getOwnedPatternTypeTypeExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PatternExpCS__OwnedPatternTypeAssignment_2"


    // $ANTLR start "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2"
    // InternalQVTbase.g:22426:1: rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2 : ( ruleExpCS ) ;
    public final void rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22430:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22431:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22431:1: ( ruleExpCS )
            // InternalQVTbase.g:22432:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLambdaLiteralExpCSAccess().getOwnedExpressionCSExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LambdaLiteralExpCS__OwnedExpressionCSAssignment_2"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedTypeAssignment_0"
    // InternalQVTbase.g:22441:1: rule__MapLiteralExpCS__OwnedTypeAssignment_0 : ( ruleMapTypeCS ) ;
    public final void rule__MapLiteralExpCS__OwnedTypeAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22445:1: ( ( ruleMapTypeCS ) )
            // InternalQVTbase.g:22446:1: ( ruleMapTypeCS )
            {
            // InternalQVTbase.g:22446:1: ( ruleMapTypeCS )
            // InternalQVTbase.g:22447:1: ruleMapTypeCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapTypeCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedTypeMapTypeCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedTypeAssignment_0"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0"
    // InternalQVTbase.g:22456:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_0 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22460:1: ( ( ruleMapLiteralPartCS ) )
            // InternalQVTbase.g:22461:1: ( ruleMapLiteralPartCS )
            {
            // InternalQVTbase.g:22461:1: ( ruleMapLiteralPartCS )
            // InternalQVTbase.g:22462:1: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1"
    // InternalQVTbase.g:22471:1: rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1 : ( ruleMapLiteralPartCS ) ;
    public final void rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22475:1: ( ( ruleMapLiteralPartCS ) )
            // InternalQVTbase.g:22476:1: ( ruleMapLiteralPartCS )
            {
            // InternalQVTbase.g:22476:1: ( ruleMapLiteralPartCS )
            // InternalQVTbase.g:22477:1: ruleMapLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMapLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralExpCSAccess().getOwnedPartsMapLiteralPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralExpCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__MapLiteralPartCS__OwnedKeyAssignment_0"
    // InternalQVTbase.g:22486:1: rule__MapLiteralPartCS__OwnedKeyAssignment_0 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedKeyAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22490:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22491:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22491:1: ( ruleExpCS )
            // InternalQVTbase.g:22492:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedKeyExpCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__OwnedKeyAssignment_0"


    // $ANTLR start "rule__MapLiteralPartCS__OwnedValueAssignment_2"
    // InternalQVTbase.g:22501:1: rule__MapLiteralPartCS__OwnedValueAssignment_2 : ( ruleExpCS ) ;
    public final void rule__MapLiteralPartCS__OwnedValueAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22505:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22506:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22506:1: ( ruleExpCS )
            // InternalQVTbase.g:22507:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMapLiteralPartCSAccess().getOwnedValueExpCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MapLiteralPartCS__OwnedValueAssignment_2"


    // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_2"
    // InternalQVTbase.g:22516:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_2 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22520:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalQVTbase.g:22521:1: ( ruleTupleLiteralPartCS )
            {
            // InternalQVTbase.g:22521:1: ( ruleTupleLiteralPartCS )
            // InternalQVTbase.g:22522:1: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTupleLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_2"


    // $ANTLR start "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1"
    // InternalQVTbase.g:22531:1: rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1 : ( ruleTupleLiteralPartCS ) ;
    public final void rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22535:1: ( ( ruleTupleLiteralPartCS ) )
            // InternalQVTbase.g:22536:1: ( ruleTupleLiteralPartCS )
            {
            // InternalQVTbase.g:22536:1: ( ruleTupleLiteralPartCS )
            // InternalQVTbase.g:22537:1: ruleTupleLiteralPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTupleLiteralPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralExpCSAccess().getOwnedPartsTupleLiteralPartCSParserRuleCall_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralExpCS__OwnedPartsAssignment_3_1"


    // $ANTLR start "rule__TupleLiteralPartCS__NameAssignment_0"
    // InternalQVTbase.g:22546:1: rule__TupleLiteralPartCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TupleLiteralPartCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22550:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:22551:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:22551:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:22552:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__NameAssignment_0"


    // $ANTLR start "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1"
    // InternalQVTbase.g:22561:1: rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22565:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:22566:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:22566:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:22567:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3"
    // InternalQVTbase.g:22576:1: rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22580:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22581:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22581:1: ( ruleExpCS )
            // InternalQVTbase.g:22582:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTupleLiteralPartCSAccess().getOwnedInitExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TupleLiteralPartCS__OwnedInitExpressionAssignment_3"


    // $ANTLR start "rule__NumberLiteralExpCS__SymbolAssignment"
    // InternalQVTbase.g:22591:1: rule__NumberLiteralExpCS__SymbolAssignment : ( ruleNUMBER_LITERAL ) ;
    public final void rule__NumberLiteralExpCS__SymbolAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22595:1: ( ( ruleNUMBER_LITERAL ) )
            // InternalQVTbase.g:22596:1: ( ruleNUMBER_LITERAL )
            {
            // InternalQVTbase.g:22596:1: ( ruleNUMBER_LITERAL )
            // InternalQVTbase.g:22597:1: ruleNUMBER_LITERAL
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNUMBER_LITERAL();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNumberLiteralExpCSAccess().getSymbolNUMBER_LITERALParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NumberLiteralExpCS__SymbolAssignment"


    // $ANTLR start "rule__StringLiteralExpCS__SegmentsAssignment"
    // InternalQVTbase.g:22606:1: rule__StringLiteralExpCS__SegmentsAssignment : ( ruleStringLiteral ) ;
    public final void rule__StringLiteralExpCS__SegmentsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22610:1: ( ( ruleStringLiteral ) )
            // InternalQVTbase.g:22611:1: ( ruleStringLiteral )
            {
            // InternalQVTbase.g:22611:1: ( ruleStringLiteral )
            // InternalQVTbase.g:22612:1: ruleStringLiteral
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleStringLiteral();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getStringLiteralExpCSAccess().getSegmentsStringLiteralParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__StringLiteralExpCS__SegmentsAssignment"


    // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_0"
    // InternalQVTbase.g:22621:1: rule__BooleanLiteralExpCS__SymbolAssignment_0 : ( ( 'true' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22625:1: ( ( ( 'true' ) ) )
            // InternalQVTbase.g:22626:1: ( ( 'true' ) )
            {
            // InternalQVTbase.g:22626:1: ( ( 'true' ) )
            // InternalQVTbase.g:22627:1: ( 'true' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }
            // InternalQVTbase.g:22628:1: ( 'true' )
            // InternalQVTbase.g:22629:1: 'true'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }
            match(input,128,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolTrueKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_0"


    // $ANTLR start "rule__BooleanLiteralExpCS__SymbolAssignment_1"
    // InternalQVTbase.g:22644:1: rule__BooleanLiteralExpCS__SymbolAssignment_1 : ( ( 'false' ) ) ;
    public final void rule__BooleanLiteralExpCS__SymbolAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22648:1: ( ( ( 'false' ) ) )
            // InternalQVTbase.g:22649:1: ( ( 'false' ) )
            {
            // InternalQVTbase.g:22649:1: ( ( 'false' ) )
            // InternalQVTbase.g:22650:1: ( 'false' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }
            // InternalQVTbase.g:22651:1: ( 'false' )
            // InternalQVTbase.g:22652:1: 'false'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }
            match(input,129,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getBooleanLiteralExpCSAccess().getSymbolFalseKeyword_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__BooleanLiteralExpCS__SymbolAssignment_1"


    // $ANTLR start "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1"
    // InternalQVTbase.g:22667:1: rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22671:1: ( ( ruleMultiplicityCS ) )
            // InternalQVTbase.g:22672:1: ( ruleMultiplicityCS )
            {
            // InternalQVTbase.g:22672:1: ( ruleMultiplicityCS )
            // InternalQVTbase.g:22673:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralWithMultiplicityCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralWithMultiplicityCS__OwnedMultiplicityAssignment_1"


    // $ANTLR start "rule__TypeLiteralExpCS__OwnedTypeAssignment"
    // InternalQVTbase.g:22682:1: rule__TypeLiteralExpCS__OwnedTypeAssignment : ( ruleTypeLiteralWithMultiplicityCS ) ;
    public final void rule__TypeLiteralExpCS__OwnedTypeAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22686:1: ( ( ruleTypeLiteralWithMultiplicityCS ) )
            // InternalQVTbase.g:22687:1: ( ruleTypeLiteralWithMultiplicityCS )
            {
            // InternalQVTbase.g:22687:1: ( ruleTypeLiteralWithMultiplicityCS )
            // InternalQVTbase.g:22688:1: ruleTypeLiteralWithMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeLiteralWithMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeLiteralExpCSAccess().getOwnedTypeTypeLiteralWithMultiplicityCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeLiteralExpCS__OwnedTypeAssignment"


    // $ANTLR start "rule__TypeNameExpCS__OwnedPathNameAssignment_0"
    // InternalQVTbase.g:22697:1: rule__TypeNameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypeNameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22701:1: ( ( rulePathNameCS ) )
            // InternalQVTbase.g:22702:1: ( rulePathNameCS )
            {
            // InternalQVTbase.g:22702:1: ( rulePathNameCS )
            // InternalQVTbase.g:22703:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0"
    // InternalQVTbase.g:22712:1: rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22716:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalQVTbase.g:22717:1: ( ruleCurlyBracketedClauseCS )
            {
            // InternalQVTbase.g:22717:1: ( ruleCurlyBracketedClauseCS )
            // InternalQVTbase.g:22718:1: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCurlyBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_1_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedCurlyBracketedClauseAssignment_1_0"


    // $ANTLR start "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1"
    // InternalQVTbase.g:22727:1: rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1 : ( ruleExpCS ) ;
    public final void rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22731:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22732:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22732:1: ( ruleExpCS )
            // InternalQVTbase.g:22733:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeNameExpCSAccess().getOwnedPatternGuardExpCSParserRuleCall_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeNameExpCS__OwnedPatternGuardAssignment_1_1_1"


    // $ANTLR start "rule__TypeExpCS__OwnedMultiplicityAssignment_1"
    // InternalQVTbase.g:22742:1: rule__TypeExpCS__OwnedMultiplicityAssignment_1 : ( ruleMultiplicityCS ) ;
    public final void rule__TypeExpCS__OwnedMultiplicityAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22746:1: ( ( ruleMultiplicityCS ) )
            // InternalQVTbase.g:22747:1: ( ruleMultiplicityCS )
            {
            // InternalQVTbase.g:22747:1: ( ruleMultiplicityCS )
            // InternalQVTbase.g:22748:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeExpCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeExpCS__OwnedMultiplicityAssignment_1"


    // $ANTLR start "rule__ExpCS__NameAssignment_0_1_1"
    // InternalQVTbase.g:22757:1: rule__ExpCS__NameAssignment_0_1_1 : ( ruleBinaryOperatorName ) ;
    public final void rule__ExpCS__NameAssignment_0_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22761:1: ( ( ruleBinaryOperatorName ) )
            // InternalQVTbase.g:22762:1: ( ruleBinaryOperatorName )
            {
            // InternalQVTbase.g:22762:1: ( ruleBinaryOperatorName )
            // InternalQVTbase.g:22763:1: ruleBinaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleBinaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getNameBinaryOperatorNameParserRuleCall_0_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__NameAssignment_0_1_1"


    // $ANTLR start "rule__ExpCS__OwnedRightAssignment_0_1_2"
    // InternalQVTbase.g:22772:1: rule__ExpCS__OwnedRightAssignment_0_1_2 : ( ruleExpCS ) ;
    public final void rule__ExpCS__OwnedRightAssignment_0_1_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22776:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22777:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22777:1: ( ruleExpCS )
            // InternalQVTbase.g:22778:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getExpCSAccess().getOwnedRightExpCSParserRuleCall_0_1_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ExpCS__OwnedRightAssignment_0_1_2"


    // $ANTLR start "rule__PrefixedLetExpCS__NameAssignment_0_1"
    // InternalQVTbase.g:22787:1: rule__PrefixedLetExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedLetExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22791:1: ( ( ruleUnaryOperatorName ) )
            // InternalQVTbase.g:22792:1: ( ruleUnaryOperatorName )
            {
            // InternalQVTbase.g:22792:1: ( ruleUnaryOperatorName )
            // InternalQVTbase.g:22793:1: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__NameAssignment_0_1"


    // $ANTLR start "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2"
    // InternalQVTbase.g:22802:1: rule__PrefixedLetExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedLetExpCS ) ;
    public final void rule__PrefixedLetExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22806:1: ( ( rulePrefixedLetExpCS ) )
            // InternalQVTbase.g:22807:1: ( rulePrefixedLetExpCS )
            {
            // InternalQVTbase.g:22807:1: ( rulePrefixedLetExpCS )
            // InternalQVTbase.g:22808:1: rulePrefixedLetExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedLetExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedLetExpCSAccess().getOwnedRightPrefixedLetExpCSParserRuleCall_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedLetExpCS__OwnedRightAssignment_0_2"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__NameAssignment_0_1"
    // InternalQVTbase.g:22817:1: rule__PrefixedPrimaryExpCS__NameAssignment_0_1 : ( ruleUnaryOperatorName ) ;
    public final void rule__PrefixedPrimaryExpCS__NameAssignment_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22821:1: ( ( ruleUnaryOperatorName ) )
            // InternalQVTbase.g:22822:1: ( ruleUnaryOperatorName )
            {
            // InternalQVTbase.g:22822:1: ( ruleUnaryOperatorName )
            // InternalQVTbase.g:22823:1: ruleUnaryOperatorName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnaryOperatorName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getNameUnaryOperatorNameParserRuleCall_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__NameAssignment_0_1"


    // $ANTLR start "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2"
    // InternalQVTbase.g:22832:1: rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2 : ( rulePrefixedPrimaryExpCS ) ;
    public final void rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22836:1: ( ( rulePrefixedPrimaryExpCS ) )
            // InternalQVTbase.g:22837:1: ( rulePrefixedPrimaryExpCS )
            {
            // InternalQVTbase.g:22837:1: ( rulePrefixedPrimaryExpCS )
            // InternalQVTbase.g:22838:1: rulePrefixedPrimaryExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePrefixedPrimaryExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPrefixedPrimaryExpCSAccess().getOwnedRightPrefixedPrimaryExpCSParserRuleCall_0_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PrefixedPrimaryExpCS__OwnedRightAssignment_0_2"


    // $ANTLR start "rule__NameExpCS__OwnedPathNameAssignment_0"
    // InternalQVTbase.g:22847:1: rule__NameExpCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__NameExpCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22851:1: ( ( rulePathNameCS ) )
            // InternalQVTbase.g:22852:1: ( rulePathNameCS )
            {
            // InternalQVTbase.g:22852:1: ( rulePathNameCS )
            // InternalQVTbase.g:22853:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1"
    // InternalQVTbase.g:22862:1: rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1 : ( ruleSquareBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22866:1: ( ( ruleSquareBracketedClauseCS ) )
            // InternalQVTbase.g:22867:1: ( ruleSquareBracketedClauseCS )
            {
            // InternalQVTbase.g:22867:1: ( ruleSquareBracketedClauseCS )
            // InternalQVTbase.g:22868:1: ruleSquareBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleSquareBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedSquareBracketedClausesSquareBracketedClauseCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedSquareBracketedClausesAssignment_1"


    // $ANTLR start "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2"
    // InternalQVTbase.g:22877:1: rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22881:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalQVTbase.g:22882:1: ( ruleRoundBracketedClauseCS )
            {
            // InternalQVTbase.g:22882:1: ( ruleRoundBracketedClauseCS )
            // InternalQVTbase.g:22883:1: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleRoundBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedRoundBracketedClauseAssignment_2"


    // $ANTLR start "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3"
    // InternalQVTbase.g:22892:1: rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3 : ( ruleCurlyBracketedClauseCS ) ;
    public final void rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22896:1: ( ( ruleCurlyBracketedClauseCS ) )
            // InternalQVTbase.g:22897:1: ( ruleCurlyBracketedClauseCS )
            {
            // InternalQVTbase.g:22897:1: ( ruleCurlyBracketedClauseCS )
            // InternalQVTbase.g:22898:1: ruleCurlyBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCurlyBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getOwnedCurlyBracketedClauseCurlyBracketedClauseCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__OwnedCurlyBracketedClauseAssignment_3"


    // $ANTLR start "rule__NameExpCS__IsPreAssignment_4_0"
    // InternalQVTbase.g:22907:1: rule__NameExpCS__IsPreAssignment_4_0 : ( ( '@' ) ) ;
    public final void rule__NameExpCS__IsPreAssignment_4_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22911:1: ( ( ( '@' ) ) )
            // InternalQVTbase.g:22912:1: ( ( '@' ) )
            {
            // InternalQVTbase.g:22912:1: ( ( '@' ) )
            // InternalQVTbase.g:22913:1: ( '@' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }
            // InternalQVTbase.g:22914:1: ( '@' )
            // InternalQVTbase.g:22915:1: '@'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }
            match(input,130,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNameExpCSAccess().getIsPreCommercialAtKeyword_4_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NameExpCS__IsPreAssignment_4_0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0"
    // InternalQVTbase.g:22930:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22934:1: ( ( ruleShadowPartCS ) )
            // InternalQVTbase.g:22935:1: ( ruleShadowPartCS )
            {
            // InternalQVTbase.g:22935:1: ( ruleShadowPartCS )
            // InternalQVTbase.g:22936:1: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleShadowPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_0"


    // $ANTLR start "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1"
    // InternalQVTbase.g:22945:1: rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1 : ( ruleShadowPartCS ) ;
    public final void rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22949:1: ( ( ruleShadowPartCS ) )
            // InternalQVTbase.g:22950:1: ( ruleShadowPartCS )
            {
            // InternalQVTbase.g:22950:1: ( ruleShadowPartCS )
            // InternalQVTbase.g:22951:1: ruleShadowPartCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleShadowPartCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCurlyBracketedClauseCSAccess().getOwnedPartsShadowPartCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CurlyBracketedClauseCS__OwnedPartsAssignment_2_1_1"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0"
    // InternalQVTbase.g:22960:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0 : ( ruleNavigatingArgCS ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22964:1: ( ( ruleNavigatingArgCS ) )
            // InternalQVTbase.g:22965:1: ( ruleNavigatingArgCS )
            {
            // InternalQVTbase.g:22965:1: ( ruleNavigatingArgCS )
            // InternalQVTbase.g:22966:1: ruleNavigatingArgCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsNavigatingArgCSParserRuleCall_2_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_0"


    // $ANTLR start "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1"
    // InternalQVTbase.g:22975:1: rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1 : ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) ;
    public final void rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22979:1: ( ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) ) )
            // InternalQVTbase.g:22980:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) )
            {
            // InternalQVTbase.g:22980:1: ( ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 ) )
            // InternalQVTbase.g:22981:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0());
            }
            // InternalQVTbase.g:22982:1: ( rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0 )
            // InternalQVTbase.g:22982:2: rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__RoundBracketedClauseCS__OwnedArgumentsAlternatives_2_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getRoundBracketedClauseCSAccess().getOwnedArgumentsAlternatives_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__RoundBracketedClauseCS__OwnedArgumentsAssignment_2_1"


    // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1"
    // InternalQVTbase.g:22991:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:22995:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:22996:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:22996:1: ( ruleExpCS )
            // InternalQVTbase.g:22997:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_1"


    // $ANTLR start "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1"
    // InternalQVTbase.g:23006:1: rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1 : ( ruleExpCS ) ;
    public final void rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23010:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23011:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23011:1: ( ruleExpCS )
            // InternalQVTbase.g:23012:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getSquareBracketedClauseCSAccess().getOwnedTermsExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__SquareBracketedClauseCS__OwnedTermsAssignment_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0"
    // InternalQVTbase.g:23021:1: rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23025:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalQVTbase.g:23026:1: ( ruleNavigatingArgExpCS )
            {
            // InternalQVTbase.g:23026:1: ( ruleNavigatingArgExpCS )
            // InternalQVTbase.g:23027:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_0_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedNameExpressionAssignment_0_0"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1"
    // InternalQVTbase.g:23036:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23040:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23041:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23041:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23042:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_0_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1"
    // InternalQVTbase.g:23051:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23055:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23056:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23056:1: ( ruleExpCS )
            // InternalQVTbase.g:23057:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_0_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_0_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1"
    // InternalQVTbase.g:23066:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23070:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23071:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23071:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23072:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_1_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1"
    // InternalQVTbase.g:23081:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23085:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23086:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23086:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23087:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_1_2_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1"
    // InternalQVTbase.g:23096:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23100:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23101:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23101:1: ( ruleExpCS )
            // InternalQVTbase.g:23102:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_1_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_1_3_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1"
    // InternalQVTbase.g:23111:1: rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23115:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23116:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23116:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23117:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_0_1_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_0_1_2_0_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1"
    // InternalQVTbase.g:23126:1: rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23130:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23131:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23131:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23132:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_0_1_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedCoIteratorAssignment_0_1_2_1_1"


    // $ANTLR start "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3"
    // InternalQVTbase.g:23141:1: rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3 : ( ruleExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23145:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23146:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23146:1: ( ruleExpCS )
            // InternalQVTbase.g:23147:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_0_1_2_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedInitExpressionAssignment_0_1_2_3"


    // $ANTLR start "rule__NavigatingArgCS__OwnedTypeAssignment_1_1"
    // InternalQVTbase.g:23156:1: rule__NavigatingArgCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingArgCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23160:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23161:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23161:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23162:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingArgCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__NavigatingBarArgCS__PrefixAssignment_0"
    // InternalQVTbase.g:23171:1: rule__NavigatingBarArgCS__PrefixAssignment_0 : ( ( '|' ) ) ;
    public final void rule__NavigatingBarArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23175:1: ( ( ( '|' ) ) )
            // InternalQVTbase.g:23176:1: ( ( '|' ) )
            {
            // InternalQVTbase.g:23176:1: ( ( '|' ) )
            // InternalQVTbase.g:23177:1: ( '|' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }
            // InternalQVTbase.g:23178:1: ( '|' )
            // InternalQVTbase.g:23179:1: '|'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }
            match(input,131,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getPrefixVerticalLineKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1"
    // InternalQVTbase.g:23194:1: rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23198:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalQVTbase.g:23199:1: ( ruleNavigatingArgExpCS )
            {
            // InternalQVTbase.g:23199:1: ( ruleNavigatingArgExpCS )
            // InternalQVTbase.g:23200:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1"
    // InternalQVTbase.g:23209:1: rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23213:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23214:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23214:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23215:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1"
    // InternalQVTbase.g:23224:1: rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23228:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23229:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23229:1: ( ruleExpCS )
            // InternalQVTbase.g:23230:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingBarArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingBarArgCS__OwnedInitExpressionAssignment_2_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__PrefixAssignment_0"
    // InternalQVTbase.g:23239:1: rule__NavigatingCommaArgCS__PrefixAssignment_0 : ( ( ',' ) ) ;
    public final void rule__NavigatingCommaArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23243:1: ( ( ( ',' ) ) )
            // InternalQVTbase.g:23244:1: ( ( ',' ) )
            {
            // InternalQVTbase.g:23244:1: ( ( ',' ) )
            // InternalQVTbase.g:23245:1: ( ',' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }
            // InternalQVTbase.g:23246:1: ( ',' )
            // InternalQVTbase.g:23247:1: ','
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }
            match(input,64,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getPrefixCommaKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1"
    // InternalQVTbase.g:23262:1: rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23266:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalQVTbase.g:23267:1: ( ruleNavigatingArgExpCS )
            {
            // InternalQVTbase.g:23267:1: ( ruleNavigatingArgExpCS )
            // InternalQVTbase.g:23268:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1"
    // InternalQVTbase.g:23277:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23281:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23282:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23282:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23283:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_0_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1"
    // InternalQVTbase.g:23292:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23296:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23297:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23297:1: ( ruleExpCS )
            // InternalQVTbase.g:23298:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_0_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_0_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1"
    // InternalQVTbase.g:23307:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23311:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23312:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23312:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23313:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_1_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1"
    // InternalQVTbase.g:23322:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23326:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23327:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23327:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23328:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_1_2_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1"
    // InternalQVTbase.g:23337:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23341:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23342:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23342:1: ( ruleExpCS )
            // InternalQVTbase.g:23343:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_1_3_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_1_3_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1"
    // InternalQVTbase.g:23352:1: rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23356:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23357:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23357:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23358:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_2_0_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedTypeAssignment_2_2_0_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1"
    // InternalQVTbase.g:23367:1: rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1 : ( ruleCoIteratorVariableCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23371:1: ( ( ruleCoIteratorVariableCS ) )
            // InternalQVTbase.g:23372:1: ( ruleCoIteratorVariableCS )
            {
            // InternalQVTbase.g:23372:1: ( ruleCoIteratorVariableCS )
            // InternalQVTbase.g:23373:1: ruleCoIteratorVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleCoIteratorVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedCoIteratorCoIteratorVariableCSParserRuleCall_2_2_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedCoIteratorAssignment_2_2_1_1"


    // $ANTLR start "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3"
    // InternalQVTbase.g:23382:1: rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3 : ( ruleExpCS ) ;
    public final void rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23386:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23387:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23387:1: ( ruleExpCS )
            // InternalQVTbase.g:23388:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingCommaArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingCommaArgCS__OwnedInitExpressionAssignment_2_2_3"


    // $ANTLR start "rule__NavigatingSemiArgCS__PrefixAssignment_0"
    // InternalQVTbase.g:23397:1: rule__NavigatingSemiArgCS__PrefixAssignment_0 : ( ( ';' ) ) ;
    public final void rule__NavigatingSemiArgCS__PrefixAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23401:1: ( ( ( ';' ) ) )
            // InternalQVTbase.g:23402:1: ( ( ';' ) )
            {
            // InternalQVTbase.g:23402:1: ( ( ';' ) )
            // InternalQVTbase.g:23403:1: ( ';' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }
            // InternalQVTbase.g:23404:1: ( ';' )
            // InternalQVTbase.g:23405:1: ';'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }
            match(input,17,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getPrefixSemicolonKeyword_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__PrefixAssignment_0"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1"
    // InternalQVTbase.g:23420:1: rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1 : ( ruleNavigatingArgExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23424:1: ( ( ruleNavigatingArgExpCS ) )
            // InternalQVTbase.g:23425:1: ( ruleNavigatingArgExpCS )
            {
            // InternalQVTbase.g:23425:1: ( ruleNavigatingArgExpCS )
            // InternalQVTbase.g:23426:1: ruleNavigatingArgExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNavigatingArgExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedNameExpressionNavigatingArgExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedNameExpressionAssignment_1"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1"
    // InternalQVTbase.g:23435:1: rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23439:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23440:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23440:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23441:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1"
    // InternalQVTbase.g:23450:1: rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1 : ( ruleExpCS ) ;
    public final void rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23454:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23455:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23455:1: ( ruleExpCS )
            // InternalQVTbase.g:23456:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNavigatingSemiArgCSAccess().getOwnedInitExpressionExpCSParserRuleCall_2_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NavigatingSemiArgCS__OwnedInitExpressionAssignment_2_2_1"


    // $ANTLR start "rule__CoIteratorVariableCS__NameAssignment_0"
    // InternalQVTbase.g:23465:1: rule__CoIteratorVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__CoIteratorVariableCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23469:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:23470:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:23470:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:23471:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__NameAssignment_0"


    // $ANTLR start "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1"
    // InternalQVTbase.g:23480:1: rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1 : ( ruleTypeExpCS ) ;
    public final void rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23484:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23485:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23485:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23486:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getCoIteratorVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__CoIteratorVariableCS__OwnedTypeAssignment_1_1"


    // $ANTLR start "rule__IfExpCS__OwnedConditionAssignment_1"
    // InternalQVTbase.g:23495:1: rule__IfExpCS__OwnedConditionAssignment_1 : ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) ;
    public final void rule__IfExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23499:1: ( ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) ) )
            // InternalQVTbase.g:23500:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            {
            // InternalQVTbase.g:23500:1: ( ( rule__IfExpCS__OwnedConditionAlternatives_1_0 ) )
            // InternalQVTbase.g:23501:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0());
            }
            // InternalQVTbase.g:23502:1: ( rule__IfExpCS__OwnedConditionAlternatives_1_0 )
            // InternalQVTbase.g:23502:2: rule__IfExpCS__OwnedConditionAlternatives_1_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__IfExpCS__OwnedConditionAlternatives_1_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedConditionAlternatives_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedConditionAssignment_1"


    // $ANTLR start "rule__IfExpCS__OwnedThenExpressionAssignment_3"
    // InternalQVTbase.g:23511:1: rule__IfExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23515:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23516:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23516:1: ( ruleExpCS )
            // InternalQVTbase.g:23517:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedThenExpressionAssignment_3"


    // $ANTLR start "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4"
    // InternalQVTbase.g:23526:1: rule__IfExpCS__OwnedIfThenExpressionsAssignment_4 : ( ruleElseIfThenExpCS ) ;
    public final void rule__IfExpCS__OwnedIfThenExpressionsAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23530:1: ( ( ruleElseIfThenExpCS ) )
            // InternalQVTbase.g:23531:1: ( ruleElseIfThenExpCS )
            {
            // InternalQVTbase.g:23531:1: ( ruleElseIfThenExpCS )
            // InternalQVTbase.g:23532:1: ruleElseIfThenExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleElseIfThenExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedIfThenExpressionsElseIfThenExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedIfThenExpressionsAssignment_4"


    // $ANTLR start "rule__IfExpCS__OwnedElseExpressionAssignment_6"
    // InternalQVTbase.g:23541:1: rule__IfExpCS__OwnedElseExpressionAssignment_6 : ( ruleExpCS ) ;
    public final void rule__IfExpCS__OwnedElseExpressionAssignment_6() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23545:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23546:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23546:1: ( ruleExpCS )
            // InternalQVTbase.g:23547:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getIfExpCSAccess().getOwnedElseExpressionExpCSParserRuleCall_6_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__IfExpCS__OwnedElseExpressionAssignment_6"


    // $ANTLR start "rule__ElseIfThenExpCS__OwnedConditionAssignment_1"
    // InternalQVTbase.g:23556:1: rule__ElseIfThenExpCS__OwnedConditionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedConditionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23560:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23561:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23561:1: ( ruleExpCS )
            // InternalQVTbase.g:23562:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedConditionExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__OwnedConditionAssignment_1"


    // $ANTLR start "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3"
    // InternalQVTbase.g:23571:1: rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3 : ( ruleExpCS ) ;
    public final void rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23575:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23576:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23576:1: ( ruleExpCS )
            // InternalQVTbase.g:23577:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getElseIfThenExpCSAccess().getOwnedThenExpressionExpCSParserRuleCall_3_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__ElseIfThenExpCS__OwnedThenExpressionAssignment_3"


    // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_1"
    // InternalQVTbase.g:23586:1: rule__LetExpCS__OwnedVariablesAssignment_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23590:1: ( ( ruleLetVariableCS ) )
            // InternalQVTbase.g:23591:1: ( ruleLetVariableCS )
            {
            // InternalQVTbase.g:23591:1: ( ruleLetVariableCS )
            // InternalQVTbase.g:23592:1: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLetVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_1"


    // $ANTLR start "rule__LetExpCS__OwnedVariablesAssignment_2_1"
    // InternalQVTbase.g:23601:1: rule__LetExpCS__OwnedVariablesAssignment_2_1 : ( ruleLetVariableCS ) ;
    public final void rule__LetExpCS__OwnedVariablesAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23605:1: ( ( ruleLetVariableCS ) )
            // InternalQVTbase.g:23606:1: ( ruleLetVariableCS )
            {
            // InternalQVTbase.g:23606:1: ( ruleLetVariableCS )
            // InternalQVTbase.g:23607:1: ruleLetVariableCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLetVariableCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedVariablesLetVariableCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedVariablesAssignment_2_1"


    // $ANTLR start "rule__LetExpCS__OwnedInExpressionAssignment_4"
    // InternalQVTbase.g:23616:1: rule__LetExpCS__OwnedInExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetExpCS__OwnedInExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23620:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23621:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23621:1: ( ruleExpCS )
            // InternalQVTbase.g:23622:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetExpCSAccess().getOwnedInExpressionExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetExpCS__OwnedInExpressionAssignment_4"


    // $ANTLR start "rule__LetVariableCS__NameAssignment_0"
    // InternalQVTbase.g:23631:1: rule__LetVariableCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__LetVariableCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23635:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:23636:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:23636:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:23637:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__NameAssignment_0"


    // $ANTLR start "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1"
    // InternalQVTbase.g:23646:1: rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1 : ( ruleRoundBracketedClauseCS ) ;
    public final void rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23650:1: ( ( ruleRoundBracketedClauseCS ) )
            // InternalQVTbase.g:23651:1: ( ruleRoundBracketedClauseCS )
            {
            // InternalQVTbase.g:23651:1: ( ruleRoundBracketedClauseCS )
            // InternalQVTbase.g:23652:1: ruleRoundBracketedClauseCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleRoundBracketedClauseCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedRoundBracketedClauseRoundBracketedClauseCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedRoundBracketedClauseAssignment_1"


    // $ANTLR start "rule__LetVariableCS__OwnedTypeAssignment_2_1"
    // InternalQVTbase.g:23661:1: rule__LetVariableCS__OwnedTypeAssignment_2_1 : ( ruleTypeExpCS ) ;
    public final void rule__LetVariableCS__OwnedTypeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23665:1: ( ( ruleTypeExpCS ) )
            // InternalQVTbase.g:23666:1: ( ruleTypeExpCS )
            {
            // InternalQVTbase.g:23666:1: ( ruleTypeExpCS )
            // InternalQVTbase.g:23667:1: ruleTypeExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedTypeTypeExpCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedTypeAssignment_2_1"


    // $ANTLR start "rule__LetVariableCS__OwnedInitExpressionAssignment_4"
    // InternalQVTbase.g:23676:1: rule__LetVariableCS__OwnedInitExpressionAssignment_4 : ( ruleExpCS ) ;
    public final void rule__LetVariableCS__OwnedInitExpressionAssignment_4() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23680:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23681:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23681:1: ( ruleExpCS )
            // InternalQVTbase.g:23682:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getLetVariableCSAccess().getOwnedInitExpressionExpCSParserRuleCall_4_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__LetVariableCS__OwnedInitExpressionAssignment_4"


    // $ANTLR start "rule__NestedExpCS__OwnedExpressionAssignment_1"
    // InternalQVTbase.g:23691:1: rule__NestedExpCS__OwnedExpressionAssignment_1 : ( ruleExpCS ) ;
    public final void rule__NestedExpCS__OwnedExpressionAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23695:1: ( ( ruleExpCS ) )
            // InternalQVTbase.g:23696:1: ( ruleExpCS )
            {
            // InternalQVTbase.g:23696:1: ( ruleExpCS )
            // InternalQVTbase.g:23697:1: ruleExpCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleExpCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNestedExpCSAccess().getOwnedExpressionExpCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NestedExpCS__OwnedExpressionAssignment_1"


    // $ANTLR start "rule__MultiplicityBoundsCS__LowerBoundAssignment_0"
    // InternalQVTbase.g:23706:1: rule__MultiplicityBoundsCS__LowerBoundAssignment_0 : ( ruleLOWER ) ;
    public final void rule__MultiplicityBoundsCS__LowerBoundAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23710:1: ( ( ruleLOWER ) )
            // InternalQVTbase.g:23711:1: ( ruleLOWER )
            {
            // InternalQVTbase.g:23711:1: ( ruleLOWER )
            // InternalQVTbase.g:23712:1: ruleLOWER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleLOWER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getLowerBoundLOWERParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__LowerBoundAssignment_0"


    // $ANTLR start "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1"
    // InternalQVTbase.g:23721:1: rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1 : ( ruleUPPER ) ;
    public final void rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23725:1: ( ( ruleUPPER ) )
            // InternalQVTbase.g:23726:1: ( ruleUPPER )
            {
            // InternalQVTbase.g:23726:1: ( ruleUPPER )
            // InternalQVTbase.g:23727:1: ruleUPPER
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUPPER();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityBoundsCSAccess().getUpperBoundUPPERParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityBoundsCS__UpperBoundAssignment_1_1"


    // $ANTLR start "rule__MultiplicityCS__IsNullFreeAssignment_2_1"
    // InternalQVTbase.g:23736:1: rule__MultiplicityCS__IsNullFreeAssignment_2_1 : ( ( '|1' ) ) ;
    public final void rule__MultiplicityCS__IsNullFreeAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23740:1: ( ( ( '|1' ) ) )
            // InternalQVTbase.g:23741:1: ( ( '|1' ) )
            {
            // InternalQVTbase.g:23741:1: ( ( '|1' ) )
            // InternalQVTbase.g:23742:1: ( '|1' )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }
            // InternalQVTbase.g:23743:1: ( '|1' )
            // InternalQVTbase.g:23744:1: '|1'
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }
            match(input,132,FollowSets000.FOLLOW_2); if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityCSAccess().getIsNullFree1Keyword_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityCS__IsNullFreeAssignment_2_1"


    // $ANTLR start "rule__MultiplicityStringCS__StringBoundsAssignment"
    // InternalQVTbase.g:23759:1: rule__MultiplicityStringCS__StringBoundsAssignment : ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) ;
    public final void rule__MultiplicityStringCS__StringBoundsAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23763:1: ( ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) ) )
            // InternalQVTbase.g:23764:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            {
            // InternalQVTbase.g:23764:1: ( ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 ) )
            // InternalQVTbase.g:23765:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0());
            }
            // InternalQVTbase.g:23766:1: ( rule__MultiplicityStringCS__StringBoundsAlternatives_0 )
            // InternalQVTbase.g:23766:2: rule__MultiplicityStringCS__StringBoundsAlternatives_0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__MultiplicityStringCS__StringBoundsAlternatives_0();

            state._fsp--;
            if (state.failed) return ;

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getMultiplicityStringCSAccess().getStringBoundsAlternatives_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__MultiplicityStringCS__StringBoundsAssignment"


    // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_0"
    // InternalQVTbase.g:23775:1: rule__PathNameCS__OwnedPathElementsAssignment_0 : ( ruleFirstPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23779:1: ( ( ruleFirstPathElementCS ) )
            // InternalQVTbase.g:23780:1: ( ruleFirstPathElementCS )
            {
            // InternalQVTbase.g:23780:1: ( ruleFirstPathElementCS )
            // InternalQVTbase.g:23781:1: ruleFirstPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleFirstPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsFirstPathElementCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_0"


    // $ANTLR start "rule__PathNameCS__OwnedPathElementsAssignment_1_1"
    // InternalQVTbase.g:23790:1: rule__PathNameCS__OwnedPathElementsAssignment_1_1 : ( ruleNextPathElementCS ) ;
    public final void rule__PathNameCS__OwnedPathElementsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23794:1: ( ( ruleNextPathElementCS ) )
            // InternalQVTbase.g:23795:1: ( ruleNextPathElementCS )
            {
            // InternalQVTbase.g:23795:1: ( ruleNextPathElementCS )
            // InternalQVTbase.g:23796:1: ruleNextPathElementCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleNextPathElementCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getPathNameCSAccess().getOwnedPathElementsNextPathElementCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__PathNameCS__OwnedPathElementsAssignment_1_1"


    // $ANTLR start "rule__FirstPathElementCS__ReferredElementAssignment"
    // InternalQVTbase.g:23805:1: rule__FirstPathElementCS__ReferredElementAssignment : ( ( ruleUnrestrictedName ) ) ;
    public final void rule__FirstPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23809:1: ( ( ( ruleUnrestrictedName ) ) )
            // InternalQVTbase.g:23810:1: ( ( ruleUnrestrictedName ) )
            {
            // InternalQVTbase.g:23810:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:23811:1: ( ruleUnrestrictedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }
            // InternalQVTbase.g:23812:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:23813:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementUnrestrictedNameParserRuleCall_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getFirstPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__FirstPathElementCS__ReferredElementAssignment"


    // $ANTLR start "rule__NextPathElementCS__ReferredElementAssignment"
    // InternalQVTbase.g:23824:1: rule__NextPathElementCS__ReferredElementAssignment : ( ( ruleUnreservedName ) ) ;
    public final void rule__NextPathElementCS__ReferredElementAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23828:1: ( ( ( ruleUnreservedName ) ) )
            // InternalQVTbase.g:23829:1: ( ( ruleUnreservedName ) )
            {
            // InternalQVTbase.g:23829:1: ( ( ruleUnreservedName ) )
            // InternalQVTbase.g:23830:1: ( ruleUnreservedName )
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }
            // InternalQVTbase.g:23831:1: ( ruleUnreservedName )
            // InternalQVTbase.g:23832:1: ruleUnreservedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnreservedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementUnreservedNameParserRuleCall_0_1());
            }

            }

            if ( state.backtracking==0 ) {
               after(grammarAccess.getNextPathElementCSAccess().getReferredElementNamedElementCrossReference_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__NextPathElementCS__ReferredElementAssignment"


    // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0"
    // InternalQVTbase.g:23843:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23847:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalQVTbase.g:23848:1: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalQVTbase.g:23848:1: ( ruleTemplateParameterSubstitutionCS )
            // InternalQVTbase.g:23849:1: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateParameterSubstitutionCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_0"


    // $ANTLR start "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1"
    // InternalQVTbase.g:23858:1: rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1 : ( ruleTemplateParameterSubstitutionCS ) ;
    public final void rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23862:1: ( ( ruleTemplateParameterSubstitutionCS ) )
            // InternalQVTbase.g:23863:1: ( ruleTemplateParameterSubstitutionCS )
            {
            // InternalQVTbase.g:23863:1: ( ruleTemplateParameterSubstitutionCS )
            // InternalQVTbase.g:23864:1: ruleTemplateParameterSubstitutionCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateParameterSubstitutionCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedSubstitutionsTemplateParameterSubstitutionCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedSubstitutionsAssignment_1_1"


    // $ANTLR start "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2"
    // InternalQVTbase.g:23873:1: rule__TemplateBindingCS__OwnedMultiplicityAssignment_2 : ( ruleMultiplicityCS ) ;
    public final void rule__TemplateBindingCS__OwnedMultiplicityAssignment_2() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23877:1: ( ( ruleMultiplicityCS ) )
            // InternalQVTbase.g:23878:1: ( ruleMultiplicityCS )
            {
            // InternalQVTbase.g:23878:1: ( ruleMultiplicityCS )
            // InternalQVTbase.g:23879:1: ruleMultiplicityCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleMultiplicityCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateBindingCSAccess().getOwnedMultiplicityMultiplicityCSParserRuleCall_2_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateBindingCS__OwnedMultiplicityAssignment_2"


    // $ANTLR start "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment"
    // InternalQVTbase.g:23888:1: rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment : ( ruleTypeRefCS ) ;
    public final void rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23892:1: ( ( ruleTypeRefCS ) )
            // InternalQVTbase.g:23893:1: ( ruleTypeRefCS )
            {
            // InternalQVTbase.g:23893:1: ( ruleTypeRefCS )
            // InternalQVTbase.g:23894:1: ruleTypeRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateParameterSubstitutionCSAccess().getOwnedActualParameterTypeRefCSParserRuleCall_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateParameterSubstitutionCS__OwnedActualParameterAssignment"


    // $ANTLR start "rule__TemplateSignatureCS__OwnedParametersAssignment_1"
    // InternalQVTbase.g:23903:1: rule__TemplateSignatureCS__OwnedParametersAssignment_1 : ( ruleTypeParameterCS ) ;
    public final void rule__TemplateSignatureCS__OwnedParametersAssignment_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23907:1: ( ( ruleTypeParameterCS ) )
            // InternalQVTbase.g:23908:1: ( ruleTypeParameterCS )
            {
            // InternalQVTbase.g:23908:1: ( ruleTypeParameterCS )
            // InternalQVTbase.g:23909:1: ruleTypeParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersTypeParameterCSParserRuleCall_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersTypeParameterCSParserRuleCall_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__OwnedParametersAssignment_1"


    // $ANTLR start "rule__TemplateSignatureCS__OwnedParametersAssignment_2_1"
    // InternalQVTbase.g:23918:1: rule__TemplateSignatureCS__OwnedParametersAssignment_2_1 : ( ruleTypeParameterCS ) ;
    public final void rule__TemplateSignatureCS__OwnedParametersAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23922:1: ( ( ruleTypeParameterCS ) )
            // InternalQVTbase.g:23923:1: ( ruleTypeParameterCS )
            {
            // InternalQVTbase.g:23923:1: ( ruleTypeParameterCS )
            // InternalQVTbase.g:23924:1: ruleTypeParameterCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersTypeParameterCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypeParameterCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTemplateSignatureCSAccess().getOwnedParametersTypeParameterCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TemplateSignatureCS__OwnedParametersAssignment_2_1"


    // $ANTLR start "rule__TypeParameterCS__NameAssignment_0"
    // InternalQVTbase.g:23933:1: rule__TypeParameterCS__NameAssignment_0 : ( ruleUnrestrictedName ) ;
    public final void rule__TypeParameterCS__NameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23937:1: ( ( ruleUnrestrictedName ) )
            // InternalQVTbase.g:23938:1: ( ruleUnrestrictedName )
            {
            // InternalQVTbase.g:23938:1: ( ruleUnrestrictedName )
            // InternalQVTbase.g:23939:1: ruleUnrestrictedName
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleUnrestrictedName();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getNameUnrestrictedNameParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__NameAssignment_0"


    // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_1"
    // InternalQVTbase.g:23948:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23952:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:23953:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:23953:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:23954:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_1"


    // $ANTLR start "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1"
    // InternalQVTbase.g:23963:1: rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23967:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:23968:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:23968:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:23969:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypeParameterCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_1_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypeParameterCS__OwnedExtendsAssignment_1_2_1"


    // $ANTLR start "rule__TypedTypeRefCS__OwnedPathNameAssignment_0"
    // InternalQVTbase.g:23978:1: rule__TypedTypeRefCS__OwnedPathNameAssignment_0 : ( rulePathNameCS ) ;
    public final void rule__TypedTypeRefCS__OwnedPathNameAssignment_0() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23982:1: ( ( rulePathNameCS ) )
            // InternalQVTbase.g:23983:1: ( rulePathNameCS )
            {
            // InternalQVTbase.g:23983:1: ( rulePathNameCS )
            // InternalQVTbase.g:23984:1: rulePathNameCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            rulePathNameCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedPathNamePathNameCSParserRuleCall_0_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__OwnedPathNameAssignment_0"


    // $ANTLR start "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1"
    // InternalQVTbase.g:23993:1: rule__TypedTypeRefCS__OwnedBindingAssignment_1_1 : ( ruleTemplateBindingCS ) ;
    public final void rule__TypedTypeRefCS__OwnedBindingAssignment_1_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:23997:1: ( ( ruleTemplateBindingCS ) )
            // InternalQVTbase.g:23998:1: ( ruleTemplateBindingCS )
            {
            // InternalQVTbase.g:23998:1: ( ruleTemplateBindingCS )
            // InternalQVTbase.g:23999:1: ruleTemplateBindingCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTemplateBindingCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getTypedTypeRefCSAccess().getOwnedBindingTemplateBindingCSParserRuleCall_1_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__TypedTypeRefCS__OwnedBindingAssignment_1_1"


    // $ANTLR start "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1"
    // InternalQVTbase.g:24008:1: rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1 : ( ruleTypedRefCS ) ;
    public final void rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1() throws RecognitionException {

        		int stackSize = keepStackSize();

        try {
            // InternalQVTbase.g:24012:1: ( ( ruleTypedRefCS ) )
            // InternalQVTbase.g:24013:1: ( ruleTypedRefCS )
            {
            // InternalQVTbase.g:24013:1: ( ruleTypedRefCS )
            // InternalQVTbase.g:24014:1: ruleTypedRefCS
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0());
            }
            pushFollow(FollowSets000.FOLLOW_2);
            ruleTypedRefCS();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getWildcardTypeRefCSAccess().getOwnedExtendsTypedRefCSParserRuleCall_2_1_0());
            }

            }


            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {

            	restoreStackSize(stackSize);

        }
        return ;
    }
    // $ANTLR end "rule__WildcardTypeRefCS__OwnedExtendsAssignment_2_1"

    // $ANTLR start synpred116_InternalQVTbase
    public final void synpred116_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4248:6: ( ( ruleTypeLiteralCS ) )
        // InternalQVTbase.g:4248:6: ( ruleTypeLiteralCS )
        {
        // InternalQVTbase.g:4248:6: ( ruleTypeLiteralCS )
        // InternalQVTbase.g:4249:1: ruleTypeLiteralCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getTypeExpWithoutMultiplicityCSAccess().getTypeLiteralCSParserRuleCall_1());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTypeLiteralCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred116_InternalQVTbase

    // $ANTLR start synpred117_InternalQVTbase
    public final void synpred117_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4270:1: ( ( ( rule__ExpCS__Group_0__0 ) ) )
        // InternalQVTbase.g:4270:1: ( ( rule__ExpCS__Group_0__0 ) )
        {
        // InternalQVTbase.g:4270:1: ( ( rule__ExpCS__Group_0__0 ) )
        // InternalQVTbase.g:4271:1: ( rule__ExpCS__Group_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getExpCSAccess().getGroup_0());
        }
        // InternalQVTbase.g:4272:1: ( rule__ExpCS__Group_0__0 )
        // InternalQVTbase.g:4272:2: rule__ExpCS__Group_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__ExpCS__Group_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred117_InternalQVTbase

    // $ANTLR start synpred124_InternalQVTbase
    public final void synpred124_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4360:6: ( ( ruleTupleLiteralExpCS ) )
        // InternalQVTbase.g:4360:6: ( ruleTupleLiteralExpCS )
        {
        // InternalQVTbase.g:4360:6: ( ruleTupleLiteralExpCS )
        // InternalQVTbase.g:4361:1: ruleTupleLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTupleLiteralExpCSParserRuleCall_4());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTupleLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred124_InternalQVTbase

    // $ANTLR start synpred125_InternalQVTbase
    public final void synpred125_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4366:6: ( ( ruleMapLiteralExpCS ) )
        // InternalQVTbase.g:4366:6: ( ruleMapLiteralExpCS )
        {
        // InternalQVTbase.g:4366:6: ( ruleMapLiteralExpCS )
        // InternalQVTbase.g:4367:1: ruleMapLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getMapLiteralExpCSParserRuleCall_5());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleMapLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred125_InternalQVTbase

    // $ANTLR start synpred126_InternalQVTbase
    public final void synpred126_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4372:6: ( ( ruleCollectionLiteralExpCS ) )
        // InternalQVTbase.g:4372:6: ( ruleCollectionLiteralExpCS )
        {
        // InternalQVTbase.g:4372:6: ( ruleCollectionLiteralExpCS )
        // InternalQVTbase.g:4373:1: ruleCollectionLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getCollectionLiteralExpCSParserRuleCall_6());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleCollectionLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred126_InternalQVTbase

    // $ANTLR start synpred128_InternalQVTbase
    public final void synpred128_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4384:6: ( ( ruleTypeLiteralExpCS ) )
        // InternalQVTbase.g:4384:6: ( ruleTypeLiteralExpCS )
        {
        // InternalQVTbase.g:4384:6: ( ruleTypeLiteralExpCS )
        // InternalQVTbase.g:4385:1: ruleTypeLiteralExpCS
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getPrimaryExpCSAccess().getTypeLiteralExpCSParserRuleCall_8());
        }
        pushFollow(FollowSets000.FOLLOW_2);
        ruleTypeLiteralExpCS();

        state._fsp--;
        if (state.failed) return ;

        }


        }
    }
    // $ANTLR end synpred128_InternalQVTbase

    // $ANTLR start synpred132_InternalQVTbase
    public final void synpred132_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4456:1: ( ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) ) )
        // InternalQVTbase.g:4456:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
        {
        // InternalQVTbase.g:4456:1: ( ( rule__NavigatingArgCS__Group_0_1_0__0 ) )
        // InternalQVTbase.g:4457:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_0());
        }
        // InternalQVTbase.g:4458:1: ( rule__NavigatingArgCS__Group_0_1_0__0 )
        // InternalQVTbase.g:4458:2: rule__NavigatingArgCS__Group_0_1_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingArgCS__Group_0_1_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred132_InternalQVTbase

    // $ANTLR start synpred133_InternalQVTbase
    public final void synpred133_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4462:6: ( ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) ) )
        // InternalQVTbase.g:4462:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
        {
        // InternalQVTbase.g:4462:6: ( ( rule__NavigatingArgCS__Group_0_1_1__0 ) )
        // InternalQVTbase.g:4463:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingArgCSAccess().getGroup_0_1_1());
        }
        // InternalQVTbase.g:4464:1: ( rule__NavigatingArgCS__Group_0_1_1__0 )
        // InternalQVTbase.g:4464:2: rule__NavigatingArgCS__Group_0_1_1__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingArgCS__Group_0_1_1__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred133_InternalQVTbase

    // $ANTLR start synpred134_InternalQVTbase
    public final void synpred134_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4484:1: ( ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) ) )
        // InternalQVTbase.g:4484:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
        {
        // InternalQVTbase.g:4484:1: ( ( rule__NavigatingCommaArgCS__Group_2_0__0 ) )
        // InternalQVTbase.g:4485:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_0());
        }
        // InternalQVTbase.g:4486:1: ( rule__NavigatingCommaArgCS__Group_2_0__0 )
        // InternalQVTbase.g:4486:2: rule__NavigatingCommaArgCS__Group_2_0__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingCommaArgCS__Group_2_0__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred134_InternalQVTbase

    // $ANTLR start synpred135_InternalQVTbase
    public final void synpred135_InternalQVTbase_fragment() throws RecognitionException {
        // InternalQVTbase.g:4490:6: ( ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) ) )
        // InternalQVTbase.g:4490:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
        {
        // InternalQVTbase.g:4490:6: ( ( rule__NavigatingCommaArgCS__Group_2_1__0 ) )
        // InternalQVTbase.g:4491:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
        {
        if ( state.backtracking==0 ) {
           before(grammarAccess.getNavigatingCommaArgCSAccess().getGroup_2_1());
        }
        // InternalQVTbase.g:4492:1: ( rule__NavigatingCommaArgCS__Group_2_1__0 )
        // InternalQVTbase.g:4492:2: rule__NavigatingCommaArgCS__Group_2_1__0
        {
        pushFollow(FollowSets000.FOLLOW_2);
        rule__NavigatingCommaArgCS__Group_2_1__0();

        state._fsp--;
        if (state.failed) return ;

        }


        }


        }
    }
    // $ANTLR end synpred135_InternalQVTbase

    // Delegated rules

    public final boolean synpred134_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred134_InternalQVTbase_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 synpred128_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred128_InternalQVTbase_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 synpred132_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred132_InternalQVTbase_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 synpred117_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred117_InternalQVTbase_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 synpred124_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred124_InternalQVTbase_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 synpred135_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred135_InternalQVTbase_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 synpred125_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred125_InternalQVTbase_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 synpred116_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred116_InternalQVTbase_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 synpred126_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred126_InternalQVTbase_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 synpred133_InternalQVTbase() {
        state.backtracking++;
        int start = input.mark();
        try {
            synpred133_InternalQVTbase_fragment(); // can never throw exception
        } catch (RecognitionException re) {
            System.err.println("impossible: "+re);
        }
        boolean success = !state.failed;
        input.rewind(start);
        state.backtracking--;
        state.failed=false;
        return success;
    }


    protected DFA41 dfa41 = new DFA41(this);
    protected DFA42 dfa42 = new DFA42(this);
    protected DFA45 dfa45 = new DFA45(this);
    static final String dfa_1s = "\23\uffff";
    static final String dfa_2s = "\1\6\12\uffff\5\0\3\uffff";
    static final String dfa_3s = "\1\71\12\uffff\5\0\3\uffff";
    static final String dfa_4s = "\1\uffff\1\1\1\uffff\1\2\16\uffff\1\3";
    static final String dfa_5s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\3\uffff}>";
    static final String[] dfa_6s = {
            "\2\1\43\uffff\12\3\1\13\1\14\1\15\1\16\1\17",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            ""
    };

    static final short[] dfa_1 = DFA.unpackEncodedString(dfa_1s);
    static final char[] dfa_2 = DFA.unpackEncodedStringToUnsignedChars(dfa_2s);
    static final char[] dfa_3 = DFA.unpackEncodedStringToUnsignedChars(dfa_3s);
    static final short[] dfa_4 = DFA.unpackEncodedString(dfa_4s);
    static final short[] dfa_5 = DFA.unpackEncodedString(dfa_5s);
    static final short[][] dfa_6 = unpackEncodedStringArray(dfa_6s);

    class DFA41 extends DFA {

        public DFA41(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 41;
            this.eot = dfa_1;
            this.eof = dfa_1;
            this.min = dfa_2;
            this.max = dfa_3;
            this.accept = dfa_4;
            this.special = dfa_5;
            this.transition = dfa_6;
        }
        public String getDescription() {
            return "4237:1: rule__TypeExpWithoutMultiplicityCS__Alternatives : ( ( ruleTypeNameExpCS ) | ( ruleTypeLiteralCS ) | ( ruleCollectionPatternCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA41_11 = input.LA(1);


                        int index41_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred116_InternalQVTbase()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index41_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA41_12 = input.LA(1);


                        int index41_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred116_InternalQVTbase()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index41_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA41_13 = input.LA(1);


                        int index41_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred116_InternalQVTbase()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index41_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 :
                        int LA41_14 = input.LA(1);


                        int index41_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred116_InternalQVTbase()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index41_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 :
                        int LA41_15 = input.LA(1);


                        int index41_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred116_InternalQVTbase()) ) {s = 3;}

                        else if ( (true) ) {s = 18;}


                        input.seek(index41_15);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 41, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_7s = "\41\uffff";
    static final String dfa_8s = "\1\4\3\0\35\uffff";
    static final String dfa_9s = "\1\u0081\3\0\35\uffff";
    static final String dfa_10s = "\4\uffff\1\1\33\uffff\1\2";
    static final String dfa_11s = "\1\uffff\1\0\1\1\1\2\35\uffff}>";
    static final String[] dfa_12s = {
            "\4\4\13\uffff\1\1\1\2\1\3\1\4\24\uffff\17\4\15\uffff\1\4\12\uffff\1\4\1\uffff\2\4\4\uffff\1\4\4\uffff\1\40\1\4\37\uffff\2\4",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] dfa_7 = DFA.unpackEncodedString(dfa_7s);
    static final char[] dfa_8 = DFA.unpackEncodedStringToUnsignedChars(dfa_8s);
    static final char[] dfa_9 = DFA.unpackEncodedStringToUnsignedChars(dfa_9s);
    static final short[] dfa_10 = DFA.unpackEncodedString(dfa_10s);
    static final short[] dfa_11 = DFA.unpackEncodedString(dfa_11s);
    static final short[][] dfa_12 = unpackEncodedStringArray(dfa_12s);

    class DFA42 extends DFA {

        public DFA42(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 42;
            this.eot = dfa_7;
            this.eof = dfa_7;
            this.min = dfa_8;
            this.max = dfa_9;
            this.accept = dfa_10;
            this.special = dfa_11;
            this.transition = dfa_12;
        }
        public String getDescription() {
            return "4265:1: rule__ExpCS__Alternatives : ( ( ( rule__ExpCS__Group_0__0 ) ) | ( rulePrefixedLetExpCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA42_1 = input.LA(1);


                        int index42_1 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred117_InternalQVTbase()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index42_1);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA42_2 = input.LA(1);


                        int index42_2 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred117_InternalQVTbase()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index42_2);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA42_3 = input.LA(1);


                        int index42_3 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred117_InternalQVTbase()) ) {s = 4;}

                        else if ( (true) ) {s = 32;}


                        input.seek(index42_3);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 42, _s, input);
            error(nvae);
            throw nvae;
        }
    }
    static final String dfa_13s = "\40\uffff";
    static final String dfa_14s = "\1\4\12\uffff\7\0\16\uffff";
    static final String dfa_15s = "\1\u0081\12\uffff\7\0\16\uffff";
    static final String dfa_16s = "\1\uffff\1\1\1\2\1\3\1\4\15\uffff\1\10\1\11\7\uffff\1\12\1\uffff\1\5\1\6\1\7";
    static final String dfa_17s = "\13\uffff\1\0\1\1\1\2\1\3\1\4\1\5\1\6\16\uffff}>";
    static final String[] dfa_18s = {
            "\2\4\2\33\16\uffff\1\4\24\uffff\1\14\1\13\10\23\1\15\1\16\1\17\1\20\1\21\15\uffff\1\1\12\uffff\1\22\1\uffff\2\4\4\uffff\1\2\5\uffff\1\3\37\uffff\2\4",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "\1\uffff",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            "",
            ""
    };

    static final short[] dfa_13 = DFA.unpackEncodedString(dfa_13s);
    static final char[] dfa_14 = DFA.unpackEncodedStringToUnsignedChars(dfa_14s);
    static final char[] dfa_15 = DFA.unpackEncodedStringToUnsignedChars(dfa_15s);
    static final short[] dfa_16 = DFA.unpackEncodedString(dfa_16s);
    static final short[] dfa_17 = DFA.unpackEncodedString(dfa_17s);
    static final short[][] dfa_18 = unpackEncodedStringArray(dfa_18s);

    class DFA45 extends DFA {

        public DFA45(BaseRecognizer recognizer) {
            this.recognizer = recognizer;
            this.decisionNumber = 45;
            this.eot = dfa_13;
            this.eof = dfa_13;
            this.min = dfa_14;
            this.max = dfa_15;
            this.accept = dfa_16;
            this.special = dfa_17;
            this.transition = dfa_18;
        }
        public String getDescription() {
            return "4331:1: rule__PrimaryExpCS__Alternatives : ( ( ruleNestedExpCS ) | ( ruleIfExpCS ) | ( ruleSelfExpCS ) | ( rulePrimitiveLiteralExpCS ) | ( ruleTupleLiteralExpCS ) | ( ruleMapLiteralExpCS ) | ( ruleCollectionLiteralExpCS ) | ( ruleLambdaLiteralExpCS ) | ( ruleTypeLiteralExpCS ) | ( ruleNameExpCS ) );";
        }
        public int specialStateTransition(int s, IntStream _input) throws NoViableAltException {
            TokenStream input = (TokenStream)_input;
        	int _s = s;
            switch ( s ) {
                    case 0 :
                        int LA45_11 = input.LA(1);


                        int index45_11 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred124_InternalQVTbase()) ) {s = 29;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_11);
                        if ( s>=0 ) return s;
                        break;
                    case 1 :
                        int LA45_12 = input.LA(1);


                        int index45_12 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred125_InternalQVTbase()) ) {s = 30;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_12);
                        if ( s>=0 ) return s;
                        break;
                    case 2 :
                        int LA45_13 = input.LA(1);


                        int index45_13 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred126_InternalQVTbase()) ) {s = 31;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_13);
                        if ( s>=0 ) return s;
                        break;
                    case 3 :
                        int LA45_14 = input.LA(1);


                        int index45_14 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred126_InternalQVTbase()) ) {s = 31;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_14);
                        if ( s>=0 ) return s;
                        break;
                    case 4 :
                        int LA45_15 = input.LA(1);


                        int index45_15 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred126_InternalQVTbase()) ) {s = 31;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_15);
                        if ( s>=0 ) return s;
                        break;
                    case 5 :
                        int LA45_16 = input.LA(1);


                        int index45_16 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred126_InternalQVTbase()) ) {s = 31;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_16);
                        if ( s>=0 ) return s;
                        break;
                    case 6 :
                        int LA45_17 = input.LA(1);


                        int index45_17 = input.index();
                        input.rewind();
                        s = -1;
                        if ( (synpred126_InternalQVTbase()) ) {s = 31;}

                        else if ( (synpred128_InternalQVTbase()) ) {s = 19;}


                        input.seek(index45_17);
                        if ( s>=0 ) return s;
                        break;
            }
            if (state.backtracking>0) {state.failed=true; return -1;}
            NoViableAltException nvae =
                new NoViableAltException(getDescription(), 45, _s, input);
            error(nvae);
            throw nvae;
        }
    }


    private static class FollowSets000 {
        public static final BitSet FOLLOW_1 = new BitSet(new long[]{0x0000000000000000L});
        public static final BitSet FOLLOW_2 = new BitSet(new long[]{0x0000000000000002L});
        public static final BitSet FOLLOW_3 = new BitSet(new long[]{0x0000000000000022L});
        public static final BitSet FOLLOW_4 = new BitSet(new long[]{0x1000000000000000L});
        public static final BitSet FOLLOW_5 = new BitSet(new long[]{0x00000000000000C0L});
        public static final BitSet FOLLOW_6 = new BitSet(new long[]{0x6000000020020000L});
        public static final BitSet FOLLOW_7 = new BitSet(new long[]{0x0000000000000000L,0x0000001000000000L});
        public static final BitSet FOLLOW_8 = new BitSet(new long[]{0x0000000000000000L,0x0000000800000000L});
        public static final BitSet FOLLOW_9 = new BitSet(new long[]{0x03FFF800000000C0L});
        public static final BitSet FOLLOW_10 = new BitSet(new long[]{0x0000000000000020L});
        public static final BitSet FOLLOW_11 = new BitSet(new long[]{0x0000000000000000L,0x001FFFE000000000L});
        public static final BitSet FOLLOW_12 = new BitSet(new long[]{0x8000000000000000L});
        public static final BitSet FOLLOW_13 = new BitSet(new long[]{0x0000000000000002L,0x001FFFE000000000L});
        public static final BitSet FOLLOW_14 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000001L});
        public static final BitSet FOLLOW_15 = new BitSet(new long[]{0x8000000000000000L,0x0000000000000006L});
        public static final BitSet FOLLOW_16 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000006L});
        public static final BitSet FOLLOW_17 = new BitSet(new long[]{0x20000000000000C0L});
        public static final BitSet FOLLOW_18 = new BitSet(new long[]{0x03FFF800007A01F0L,0x0000000184340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_19 = new BitSet(new long[]{0x8000000000000000L,0x3800000000000000L});
        public static final BitSet FOLLOW_20 = new BitSet(new long[]{0x0000000000000002L,0x3800000000000000L});
        public static final BitSet FOLLOW_21 = new BitSet(new long[]{0x0000000000020000L});
        public static final BitSet FOLLOW_22 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000008L});
        public static final BitSet FOLLOW_23 = new BitSet(new long[]{0x6000000000020000L,0x0000000000000080L});
        public static final BitSet FOLLOW_24 = new BitSet(new long[]{0x8000000000040000L,0x0040000000000000L});
        public static final BitSet FOLLOW_25 = new BitSet(new long[]{0x80000000000000C0L,0x0000000000000020L});
        public static final BitSet FOLLOW_26 = new BitSet(new long[]{0x00000000000000C2L,0x0000000000000020L});
        public static final BitSet FOLLOW_27 = new BitSet(new long[]{0x4000000020020000L});
        public static final BitSet FOLLOW_28 = new BitSet(new long[]{0x0000000000080010L});
        public static final BitSet FOLLOW_29 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000040L});
        public static final BitSet FOLLOW_30 = new BitSet(new long[]{0x00000000000000C0L,0x0000000000000080L});
        public static final BitSet FOLLOW_31 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000080L});
        public static final BitSet FOLLOW_32 = new BitSet(new long[]{0x00000000000000C0L,0x0000000000000100L});
        public static final BitSet FOLLOW_33 = new BitSet(new long[]{0x6000000000020000L,0x0000000000000200L});
        public static final BitSet FOLLOW_34 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000001L});
        public static final BitSet FOLLOW_35 = new BitSet(new long[]{0x0000000000000000L,0x0001866000000000L});
        public static final BitSet FOLLOW_36 = new BitSet(new long[]{0x0000000000000002L,0x0001866000000000L});
        public static final BitSet FOLLOW_37 = new BitSet(new long[]{0x8000000000000000L,0x0000000000000400L});
        public static final BitSet FOLLOW_38 = new BitSet(new long[]{0x0000000000000002L,0x0000000000000400L});
        public static final BitSet FOLLOW_39 = new BitSet(new long[]{0x6000000000000000L});
        public static final BitSet FOLLOW_40 = new BitSet(new long[]{0x0000000000000000L,0x0001860000000000L});
        public static final BitSet FOLLOW_41 = new BitSet(new long[]{0x0000000000000002L,0x0001860000000000L});
        public static final BitSet FOLLOW_42 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000800L});
        public static final BitSet FOLLOW_43 = new BitSet(new long[]{0x6000000020020000L,0x0000000000001000L});
        public static final BitSet FOLLOW_44 = new BitSet(new long[]{0x0000000000000000L,0x079FFE6000000000L});
        public static final BitSet FOLLOW_45 = new BitSet(new long[]{0x0000000000000002L,0x079FFE6000000000L});
        public static final BitSet FOLLOW_46 = new BitSet(new long[]{0x0000000000020000L,0x0000000000002000L});
        public static final BitSet FOLLOW_47 = new BitSet(new long[]{0x40000000000000C0L});
        public static final BitSet FOLLOW_48 = new BitSet(new long[]{0x80000000000000C0L});
        public static final BitSet FOLLOW_49 = new BitSet(new long[]{0x0000000000000000L,0x0000000000004000L});
        public static final BitSet FOLLOW_50 = new BitSet(new long[]{0x6000000000020000L,0x0000000000008080L});
        public static final BitSet FOLLOW_51 = new BitSet(new long[]{0x8000000000000000L,0x8000000000000000L});
        public static final BitSet FOLLOW_52 = new BitSet(new long[]{0x9000000000000000L,0x0000001800000840L});
        public static final BitSet FOLLOW_53 = new BitSet(new long[]{0x1000000000000002L,0x0000001800000840L});
        public static final BitSet FOLLOW_54 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800000L});
        public static final BitSet FOLLOW_55 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800100L});
        public static final BitSet FOLLOW_56 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000100L});
        public static final BitSet FOLLOW_57 = new BitSet(new long[]{0x2000000000000000L});
        public static final BitSet FOLLOW_58 = new BitSet(new long[]{0x4000000000000000L});
        public static final BitSet FOLLOW_59 = new BitSet(new long[]{0xA3FFF800007800F0L,0x0000000184340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_60 = new BitSet(new long[]{0x23FFF800007800F0L,0x0000000184340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_61 = new BitSet(new long[]{0x0000000000000000L,0x0000000000010000L});
        public static final BitSet FOLLOW_62 = new BitSet(new long[]{0x03FFF800007800F0L,0x0000000184340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_63 = new BitSet(new long[]{0x0000000000000000L,0x0000000000020001L});
        public static final BitSet FOLLOW_64 = new BitSet(new long[]{0x0000000020000000L});
        public static final BitSet FOLLOW_65 = new BitSet(new long[]{0x83FFF800007800F0L,0x0000000184340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_66 = new BitSet(new long[]{0x0000000000000000L,0x0000000000080000L});
        public static final BitSet FOLLOW_67 = new BitSet(new long[]{0x8000000000000000L,0x0000000000000001L});
        public static final BitSet FOLLOW_68 = new BitSet(new long[]{0x2000000020000000L});
        public static final BitSet FOLLOW_69 = new BitSet(new long[]{0x0000000000400000L});
        public static final BitSet FOLLOW_70 = new BitSet(new long[]{0x0000000000000000L,0x0000000000100000L});
        public static final BitSet FOLLOW_71 = new BitSet(new long[]{0x0000000000400030L,0x0000000000300000L,0x0000000000000003L});
        public static final BitSet FOLLOW_72 = new BitSet(new long[]{0x000007FFFFC80000L});
        public static final BitSet FOLLOW_73 = new BitSet(new long[]{0x0000000000380000L});
        public static final BitSet FOLLOW_74 = new BitSet(new long[]{0x03FFF800007800F0L,0x0000000104340080L,0x0000000000000003L});
        public static final BitSet FOLLOW_75 = new BitSet(new long[]{0x4000000000000000L,0x0000000000800080L,0x0000000000000004L});
        public static final BitSet FOLLOW_76 = new BitSet(new long[]{0x0000000000000002L,0x0000000000800000L});
        public static final BitSet FOLLOW_77 = new BitSet(new long[]{0x0000000000000000L,0x0000000000400000L});
        public static final BitSet FOLLOW_78 = new BitSet(new long[]{0x80000000000000E0L});
        public static final BitSet FOLLOW_79 = new BitSet(new long[]{0x00000000000000E0L});
        public static final BitSet FOLLOW_80 = new BitSet(new long[]{0x23FFF800007800F0L,0x0000000184340180L,0x0000000000000003L});
        public static final BitSet FOLLOW_81 = new BitSet(new long[]{0x0000000000020000L,0x0000000000000001L,0x0000000000000008L});
        public static final BitSet FOLLOW_82 = new BitSet(new long[]{0x0000000000020002L,0x0000000000000001L,0x0000000000000008L});
        public static final BitSet FOLLOW_83 = new BitSet(new long[]{0x0000000000000000L,0x0000000001000001L});
        public static final BitSet FOLLOW_84 = new BitSet(new long[]{0x2000000000000000L,0x0000000002080000L});
        public static final BitSet FOLLOW_85 = new BitSet(new long[]{0x0000000020000000L,0x0000000000080000L});
        public static final BitSet FOLLOW_86 = new BitSet(new long[]{0x0000000000000000L,0x0000000008000000L});
        public static final BitSet FOLLOW_87 = new BitSet(new long[]{0x0000000000000000L,0x0000000050000000L});
        public static final BitSet FOLLOW_88 = new BitSet(new long[]{0x0000000000000002L,0x0000000040000000L});
        public static final BitSet FOLLOW_89 = new BitSet(new long[]{0x0000000000000000L,0x0000000020000000L});
        public static final BitSet FOLLOW_90 = new BitSet(new long[]{0x0000000000000000L,0x0000000002000001L});
        public static final BitSet FOLLOW_91 = new BitSet(new long[]{0x2000000020000000L,0x0000000000000080L});
        public static final BitSet FOLLOW_92 = new BitSet(new long[]{0x0000000000000000L,0x0000000100000000L});
        public static final BitSet FOLLOW_93 = new BitSet(new long[]{0x0000000000400010L});
        public static final BitSet FOLLOW_94 = new BitSet(new long[]{0x0800000001400010L});
        public static final BitSet FOLLOW_95 = new BitSet(new long[]{0x0400000000000000L,0x0000000001000000L,0x0000000000000010L});
        public static final BitSet FOLLOW_96 = new BitSet(new long[]{0x0000000000000000L,0x0000000200000000L});
        public static final BitSet FOLLOW_97 = new BitSet(new long[]{0x0000000000000002L,0x0000000200000000L});
        public static final BitSet FOLLOW_98 = new BitSet(new long[]{0x0000000000000000L,0x0000000000800001L});
        public static final BitSet FOLLOW_99 = new BitSet(new long[]{0x0BFFF800000000C0L});
        public static final BitSet FOLLOW_100 = new BitSet(new long[]{0x0000000000000000L,0x0000000000000101L});
        public static final BitSet FOLLOW_101 = new BitSet(new long[]{0x0000000000000000L,0x0000000000008000L});
        public static final BitSet FOLLOW_102 = new BitSet(new long[]{0x0000000000000000L,0x0000000400000000L});
        public static final BitSet FOLLOW_103 = new BitSet(new long[]{0x0000000000000002L,0x0000000400000000L});
    }


}