package io.sarl.lang.ide.contentassist.antlr.internal;

import java.io.InputStream;
import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.AbstractInternalContentAssistParser;
import org.eclipse.xtext.ide.editor.contentassist.antlr.internal.DFA;
import io.sarl.lang.services.SARLGrammarAccess;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.util.HashMap;
@SuppressWarnings("all")
public class InternalSARLParser extends AbstractInternalContentAssistParser {
    @Override protected boolean isBacktracking() { return false; }
    @Override public void announceMark(int marker) { /* do nothing */ }
    @Override protected int getLookaheadThreshold() { return 5; }
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_ID", "RULE_HEX", "RULE_INT", "RULE_DECIMAL", "RULE_STRING", "RULE_RICH_TEXT", "RULE_RICH_TEXT_START", "RULE_RICH_TEXT_INBETWEEN", "RULE_COMMENT_RICH_TEXT_INBETWEEN", "RULE_RICH_TEXT_END", "RULE_COMMENT_RICH_TEXT_END", "RULE_IDENTIFIER_START", "RULE_UNICODE_ESCAPE", "RULE_IDENTIFIER_PART", "RULE_HEX_DIGIT", "RULE_IN_RICH_STRING", "RULE_IDENTIFIER_PART_IMPL", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "'**'", "'='", "'||'", "'&&'", "';'", "'val'", "'*'", "'/'", "'%'", "'!'", "'-'", "'+'", "'public'", "'private'", "'protected'", "'package'", "'abstract'", "'static'", "'dispatch'", "'final'", "'strictfp'", "'native'", "'volatile'", "'synchronized'", "'transient'", "'var'", "'def'", "'override'", "'create'", "'annotation'", "'AFTER'", "'BEFORE'", "'SEPARATOR'", "'extension'", "'class'", "'enum'", "'extends'", "'implements'", "'import'", "'interface'", "'throws'", "'+='", "'-='", "'*='", "'/='", "'%='", "'=='", "'!='", "'==='", "'!=='", "'>='", "'>'", "'<'", "'->'", "'..<'", "'..'", "'=>'", "'<>'", "'?:'", "'++'", "'--'", "'.'", "'super'", "'false'", "'event'", "','", "'{'", "'}'", "'capacity'", "'agent'", "'behavior'", "'skill'", "'space'", "'artifact'", "':'", "'new'", "'('", "')'", "'with'", "'fires'", "'on'", "'['", "']'", "'uses'", "'requires'", "'break'", "'continue'", "'assert'", "'as'", "'for'", "'switch'", "'default'", "'try'", "'finally'", "'|'", "'case'", "'FOR'", "'ENDFOR'", "'IF'", "'ENDIF'", "'ELSE'", "'ELSEIF'", "'@'", "'#'", "'instanceof'", "'if'", "'else'", "'while'", "'do'", "'null'", "'typeof'", "'throw'", "'return'", "'catch'", "'?'", "'&'", "'assume'", "'::'", "'?.'", "'true'"
    };
    public static final int T__144=144;
    public static final int T__143=143;
    public static final int RULE_HEX=5;
    public static final int T__50=50;
    public static final int T__140=140;
    public static final int T__142=142;
    public static final int T__141=141;
    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__137=137;
    public static final int T__52=52;
    public static final int T__136=136;
    public static final int T__53=53;
    public static final int T__139=139;
    public static final int T__54=54;
    public static final int T__138=138;
    public static final int T__133=133;
    public static final int T__132=132;
    public static final int T__60=60;
    public static final int T__135=135;
    public static final int T__61=61;
    public static final int T__134=134;
    public static final int RULE_ID=4;
    public static final int T__131=131;
    public static final int T__130=130;
    public static final int RULE_RICH_TEXT_START=10;
    public static final int RULE_INT=6;
    public static final int T__66=66;
    public static final int RULE_ML_COMMENT=21;
    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 RULE_UNICODE_ESCAPE=16;
    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 RULE_IDENTIFIER_PART=17;
    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 T__48=48;
    public static final int T__49=49;
    public static final int T__44=44;
    public static final int T__45=45;
    public static final int RULE_HEX_DIGIT=18;
    public static final int T__46=46;
    public static final int T__47=47;
    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 RULE_COMMENT_RICH_TEXT_END=14;
    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_IDENTIFIER_START=15;
    public static final int T__99=99;
    public static final int T__95=95;
    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 RULE_DECIMAL=7;
    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__25=25;
    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_STRING=8;
    public static final int RULE_SL_COMMENT=22;
    public static final int RULE_IN_RICH_STRING=19;
    public static final int T__77=77;
    public static final int T__119=119;
    public static final int RULE_COMMENT_RICH_TEXT_INBETWEEN=12;
    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_RICH_TEXT=9;
    public static final int T__83=83;
    public static final int T__112=112;
    public static final int RULE_WS=23;
    public static final int RULE_RICH_TEXT_END=13;
    public static final int RULE_ANY_OTHER=24;
    public static final int RULE_RICH_TEXT_INBETWEEN=11;
    public static final int RULE_IDENTIFIER_PART_IMPL=20;
    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 InternalSARLParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public InternalSARLParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

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


    	private SARLGrammarAccess grammarAccess;

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

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

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



    // $ANTLR start "entryRuleSarlScript"
    // InternalSARL.g:74:1: entryRuleSarlScript : ruleSarlScript EOF ;
    public final void entryRuleSarlScript() throws RecognitionException {
        try {
            // InternalSARL.g:75:1: ( ruleSarlScript EOF )
            // InternalSARL.g:76:1: ruleSarlScript EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getSarlScriptRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleSarlScript();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getSarlScriptRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleSarlScript"
    // InternalSARL.g:83:1: ruleSarlScript : ( ( rule__SarlScript__Group__0 ) ) ;
    public final void ruleSarlScript() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:87:2: ( ( ( rule__SarlScript__Group__0 ) ) )
            // InternalSARL.g:88:2: ( ( rule__SarlScript__Group__0 ) )
            {
            // InternalSARL.g:88:2: ( ( rule__SarlScript__Group__0 ) )
            // InternalSARL.g:89:3: ( rule__SarlScript__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getSarlScriptAccess().getGroup()); 
            }
            // InternalSARL.g:90:3: ( rule__SarlScript__Group__0 )
            // InternalSARL.g:90:4: rule__SarlScript__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__SarlScript__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getSarlScriptAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleType"
    // InternalSARL.g:99:1: entryRuleType : ruleType EOF ;
    public final void entryRuleType() throws RecognitionException {
        try {
            // InternalSARL.g:100:1: ( ruleType EOF )
            // InternalSARL.g:101:1: ruleType EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getTypeRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleType();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getTypeRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleType"
    // InternalSARL.g:108:1: ruleType : ( ( rule__Type__Group__0 ) ) ;
    public final void ruleType() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:112:2: ( ( ( rule__Type__Group__0 ) ) )
            // InternalSARL.g:113:2: ( ( rule__Type__Group__0 ) )
            {
            // InternalSARL.g:113:2: ( ( rule__Type__Group__0 ) )
            // InternalSARL.g:114:3: ( rule__Type__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getTypeAccess().getGroup()); 
            }
            // InternalSARL.g:115:3: ( rule__Type__Group__0 )
            // InternalSARL.g:115:4: rule__Type__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Type__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getTypeAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleEventMember"
    // InternalSARL.g:124:1: entryRuleEventMember : ruleEventMember EOF ;
    public final void entryRuleEventMember() throws RecognitionException {
        try {
            // InternalSARL.g:125:1: ( ruleEventMember EOF )
            // InternalSARL.g:126:1: ruleEventMember EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getEventMemberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleEventMember();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getEventMemberRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleEventMember"
    // InternalSARL.g:133:1: ruleEventMember : ( ( rule__EventMember__Group__0 ) ) ;
    public final void ruleEventMember() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:137:2: ( ( ( rule__EventMember__Group__0 ) ) )
            // InternalSARL.g:138:2: ( ( rule__EventMember__Group__0 ) )
            {
            // InternalSARL.g:138:2: ( ( rule__EventMember__Group__0 ) )
            // InternalSARL.g:139:3: ( rule__EventMember__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getEventMemberAccess().getGroup()); 
            }
            // InternalSARL.g:140:3: ( rule__EventMember__Group__0 )
            // InternalSARL.g:140:4: rule__EventMember__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__EventMember__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getEventMemberAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleCapacityMember"
    // InternalSARL.g:149:1: entryRuleCapacityMember : ruleCapacityMember EOF ;
    public final void entryRuleCapacityMember() throws RecognitionException {
        try {
            // InternalSARL.g:150:1: ( ruleCapacityMember EOF )
            // InternalSARL.g:151:1: ruleCapacityMember EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getCapacityMemberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleCapacityMember();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getCapacityMemberRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleCapacityMember"
    // InternalSARL.g:158:1: ruleCapacityMember : ( ( rule__CapacityMember__Group__0 ) ) ;
    public final void ruleCapacityMember() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:162:2: ( ( ( rule__CapacityMember__Group__0 ) ) )
            // InternalSARL.g:163:2: ( ( rule__CapacityMember__Group__0 ) )
            {
            // InternalSARL.g:163:2: ( ( rule__CapacityMember__Group__0 ) )
            // InternalSARL.g:164:3: ( rule__CapacityMember__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getCapacityMemberAccess().getGroup()); 
            }
            // InternalSARL.g:165:3: ( rule__CapacityMember__Group__0 )
            // InternalSARL.g:165:4: rule__CapacityMember__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__CapacityMember__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getCapacityMemberAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAOPMember"
    // InternalSARL.g:174:1: entryRuleAOPMember : ruleAOPMember EOF ;
    public final void entryRuleAOPMember() throws RecognitionException {
        try {
            // InternalSARL.g:175:1: ( ruleAOPMember EOF )
            // InternalSARL.g:176:1: ruleAOPMember EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getAOPMemberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleAOPMember();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getAOPMemberRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleAOPMember"
    // InternalSARL.g:183:1: ruleAOPMember : ( ( rule__AOPMember__Group__0 ) ) ;
    public final void ruleAOPMember() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:187:2: ( ( ( rule__AOPMember__Group__0 ) ) )
            // InternalSARL.g:188:2: ( ( rule__AOPMember__Group__0 ) )
            {
            // InternalSARL.g:188:2: ( ( rule__AOPMember__Group__0 ) )
            // InternalSARL.g:189:3: ( rule__AOPMember__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getAOPMemberAccess().getGroup()); 
            }
            // InternalSARL.g:190:3: ( rule__AOPMember__Group__0 )
            // InternalSARL.g:190:4: rule__AOPMember__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AOPMember__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getAOPMemberAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleMember"
    // InternalSARL.g:199:1: entryRuleMember : ruleMember EOF ;
    public final void entryRuleMember() throws RecognitionException {
        try {
            // InternalSARL.g:200:1: ( ruleMember EOF )
            // InternalSARL.g:201:1: ruleMember EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getMemberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleMember();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getMemberRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleMember"
    // InternalSARL.g:208:1: ruleMember : ( ( rule__Member__Group__0 ) ) ;
    public final void ruleMember() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:212:2: ( ( ( rule__Member__Group__0 ) ) )
            // InternalSARL.g:213:2: ( ( rule__Member__Group__0 ) )
            {
            // InternalSARL.g:213:2: ( ( rule__Member__Group__0 ) )
            // InternalSARL.g:214:3: ( rule__Member__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getMemberAccess().getGroup()); 
            }
            // InternalSARL.g:215:3: ( rule__Member__Group__0 )
            // InternalSARL.g:215:4: rule__Member__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Member__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getMemberAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleAnnotationField"
    // InternalSARL.g:224:1: entryRuleAnnotationField : ruleAnnotationField EOF ;
    public final void entryRuleAnnotationField() throws RecognitionException {
        try {
            // InternalSARL.g:225:1: ( ruleAnnotationField EOF )
            // InternalSARL.g:226:1: ruleAnnotationField EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getAnnotationFieldRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleAnnotationField();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getAnnotationFieldRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleAnnotationField"
    // InternalSARL.g:233:1: ruleAnnotationField : ( ( rule__AnnotationField__Group__0 ) ) ;
    public final void ruleAnnotationField() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:237:2: ( ( ( rule__AnnotationField__Group__0 ) ) )
            // InternalSARL.g:238:2: ( ( rule__AnnotationField__Group__0 ) )
            {
            // InternalSARL.g:238:2: ( ( rule__AnnotationField__Group__0 ) )
            // InternalSARL.g:239:3: ( rule__AnnotationField__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getAnnotationFieldAccess().getGroup()); 
            }
            // InternalSARL.g:240:3: ( rule__AnnotationField__Group__0 )
            // InternalSARL.g:240:4: rule__AnnotationField__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__AnnotationField__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getAnnotationFieldAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleParameter"
    // InternalSARL.g:249:1: entryRuleParameter : ruleParameter EOF ;
    public final void entryRuleParameter() throws RecognitionException {
        try {
            // InternalSARL.g:250:1: ( ruleParameter EOF )
            // InternalSARL.g:251:1: ruleParameter EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getParameterRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleParameter();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getParameterRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleParameter"
    // InternalSARL.g:258:1: ruleParameter : ( ( rule__Parameter__Group__0 ) ) ;
    public final void ruleParameter() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:262:2: ( ( ( rule__Parameter__Group__0 ) ) )
            // InternalSARL.g:263:2: ( ( rule__Parameter__Group__0 ) )
            {
            // InternalSARL.g:263:2: ( ( rule__Parameter__Group__0 ) )
            // InternalSARL.g:264:3: ( rule__Parameter__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getParameterAccess().getGroup()); 
            }
            // InternalSARL.g:265:3: ( rule__Parameter__Group__0 )
            // InternalSARL.g:265:4: rule__Parameter__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__Parameter__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getParameterAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleXtendEnumLiteral"
    // InternalSARL.g:274:1: entryRuleXtendEnumLiteral : ruleXtendEnumLiteral EOF ;
    public final void entryRuleXtendEnumLiteral() throws RecognitionException {
        try {
            // InternalSARL.g:275:1: ( ruleXtendEnumLiteral EOF )
            // InternalSARL.g:276:1: ruleXtendEnumLiteral EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getXtendEnumLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXtendEnumLiteral();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getXtendEnumLiteralRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleXtendEnumLiteral"
    // InternalSARL.g:283:1: ruleXtendEnumLiteral : ( ( rule__XtendEnumLiteral__Group__0 ) ) ;
    public final void ruleXtendEnumLiteral() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:287:2: ( ( ( rule__XtendEnumLiteral__Group__0 ) ) )
            // InternalSARL.g:288:2: ( ( rule__XtendEnumLiteral__Group__0 ) )
            {
            // InternalSARL.g:288:2: ( ( rule__XtendEnumLiteral__Group__0 ) )
            // InternalSARL.g:289:3: ( rule__XtendEnumLiteral__Group__0 )
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getXtendEnumLiteralAccess().getGroup()); 
            }
            // InternalSARL.g:290:3: ( rule__XtendEnumLiteral__Group__0 )
            // InternalSARL.g:290:4: rule__XtendEnumLiteral__Group__0
            {
            pushFollow(FOLLOW_2);
            rule__XtendEnumLiteral__Group__0();

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

            }

            if (! isBacktracking() ) {
               after(grammarAccess.getXtendEnumLiteralAccess().getGroup()); 
            }

            }


            }

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

            	restoreStackSize(stackSize);

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


    // $ANTLR start "entryRuleBreakExpression"
    // InternalSARL.g:299:1: entryRuleBreakExpression : ruleBreakExpression EOF ;
    public final void entryRuleBreakExpression() throws RecognitionException {
        try {
            // InternalSARL.g:300:1: ( ruleBreakExpression EOF )
            // InternalSARL.g:301:1: ruleBreakExpression EOF
            {
            if (! isBacktracking() ) {
               before(grammarAccess.getBreakExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleBreakExpression();

            state._fsp--;
            if (state.failed) return ;
            if (! isBacktracking() ) {
               after(grammarAccess.getBreakExpressionRule()); 
            }
            match(input,EOF,FOLLOW_2); if (state.failed) return ;

            }

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


    // $ANTLR start "ruleBreakExpression"
    // InternalSARL.g:308:1: ruleBreakExpression : ( ( rule__BreakExpression__Group__0 ) ) ;
    public final void ruleBreakExpression() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalSARL.g:312:2: ( ( ( rule__BreakExpression__Group__0 ) ) )
            // InternalSARL.g:313:2: ( ( rule__BreakExpression__Group__0 ) )
            {
            // InternalSARL.g:313:2: ( ( rule__BreakExpression__Group__0 ) )
            // InternalSARL.g:314:3: ( rule__BreakExpression__Group__0 )
            {
            if (! isBacktracking() ) {
