InternalXtext.g:270:1: entryRuleParameter : ruleParameter EOF ;
173430
public final void entryRuleParameter() throws RecognitionException {
        try {
            // InternalXtext.g:271:1: ( ruleParameter EOF )
            // InternalXtext.g:272:1: ruleParameter EOF
            {
             before(grammarAccess.getParameterRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParameter();

            state._fsp--;

             after(grammarAccess.getParameterRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
250029
public final void entryRuleFeatureCallID() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1334:1: ( ruleFeatureCallID EOF )
            // InternalXbaseWithAnnotations.g:1335:1: ruleFeatureCallID EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFeatureCallIDRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleFeatureCallID();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
403901
public final void entryRuleParenthesizedCondition() throws RecognitionException {
        try {
            // InternalXtext.g:721:1: ( ruleParenthesizedCondition EOF )
            // InternalXtext.g:722:1: ruleParenthesizedCondition EOF
            {
             before(grammarAccess.getParenthesizedConditionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParenthesizedCondition();

            state._fsp--;

             after(grammarAccess.getParenthesizedConditionRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1058440
public final void entryRuleEnumRule() throws RecognitionException {
        try {
            // InternalXtext.g:1396:1: ( ruleEnumRule EOF )
            // InternalXtext.g:1397:1: ruleEnumRule EOF
            {
             before(grammarAccess.getEnumRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEnumRule();

            state._fsp--;

             after(grammarAccess.getEnumRuleRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
98950
public final EObject ruleParameter() throws RecognitionException {
        EObject current = null;

        Token lv_name_0_0=null;


        	enterRule();

        try {
            // InternalXtext.g:901:2: ( ( (lv_name_0_0= RULE_ID ) ) )
            // InternalXtext.g:902:2: ( (lv_name_0_0= RULE_ID ) )
            {
            // InternalXtext.g:902:2: ( (lv_name_0_0= RULE_ID ) )
            // InternalXtext.g:903:3: (lv_name_0_0= RULE_ID )
            {
            // InternalXtext.g:903:3: (lv_name_0_0= RULE_ID )
            // InternalXtext.g:904:4: lv_name_0_0= RULE_ID
            {
            lv_name_0_0=(Token)match(input,RULE_ID,FollowSets000.FOLLOW_2); 

            				newLeafNode(lv_name_0_0, grammarAccess.getParameterAccess().getNameIDTerminalRuleCall_0());
            			

            				if (current==null) {
            					current = createModelElement(grammarAccess.getParameterRule());
            				}
            				setWithLastConsumed(
            					current,
            					"name",
            					lv_name_0_0,
            					"org.eclipse.xtext.common.Terminals.ID");
            			

            }


            }


            }


            	leaveRule();

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
195332
public final void entryRuleCharacterRange() throws RecognitionException {
        try {
            // InternalXtext.g:1371:1: ( ruleCharacterRange EOF )
            // InternalXtext.g:1372:1: ruleCharacterRange EOF
            {
             before(grammarAccess.getCharacterRangeRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleCharacterRange();

            state._fsp--;

             after(grammarAccess.getCharacterRangeRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
269733
public final void entryRuleOpUnary() throws RecognitionException {
        try {
            // InternalXbase.g:534:1: ( ruleOpUnary EOF )
            // InternalXbase.g:535:1: ruleOpUnary EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpUnaryRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpUnary();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
149174
public final void entryRuleAbstractRule() throws RecognitionException {
        try {
            // InternalXtext.g:104:1: ( ruleAbstractRule EOF )
            // InternalXtext.g:105:1: ruleAbstractRule EOF
            {
             before(grammarAccess.getAbstractRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractRule();

            state._fsp--;

             after(grammarAccess.getAbstractRuleRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
838693
public final void entryRuleXAnnotationElementValueOrCommaList() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:109:1: ( ruleXAnnotationElementValueOrCommaList EOF )
            // InternalXbaseWithAnnotations.g:110:1: ruleXAnnotationElementValueOrCommaList EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXAnnotationElementValueOrCommaListRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXAnnotationElementValueOrCommaList();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
367796
public final void entryRuleTerminalRuleCall() throws RecognitionException {
        try {
            // InternalXtext.g:771:1: ( ruleTerminalRuleCall EOF )
            // InternalXtext.g:772:1: ruleTerminalRuleCall EOF
            {
             before(grammarAccess.getTerminalRuleCallRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTerminalRuleCall();

            state._fsp--;

             after(grammarAccess.getTerminalRuleCallRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1128441
public final void entryRuleXPostfixOperation() throws RecognitionException {
        try {
            // InternalXbase.g:584:1: ( ruleXPostfixOperation EOF )
            // InternalXbase.g:585:1: ruleXPostfixOperation EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXPostfixOperationRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXPostfixOperation();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1323734
public final void entryRuleOpOther() throws RecognitionException {
        try {
            // InternalXbase.g:384:1: ( ruleOpOther EOF )
            // InternalXbase.g:385:1: ruleOpOther EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpOtherRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpOther();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
870998
public final void entryRuleAnnotation() throws RecognitionException {
        try {
            // InternalXtext.g:204:1: ( ruleAnnotation EOF )
            // InternalXtext.g:205:1: ruleAnnotation EOF
            {
             before(grammarAccess.getAnnotationRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAnnotation();

            state._fsp--;

             after(grammarAccess.getAnnotationRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
725281
public final void entryRuleWildcard() throws RecognitionException {
        try {
            // InternalXtext.g:1321:1: ( ruleWildcard EOF )
            // InternalXtext.g:1322:1: ruleWildcard EOF
            {
             before(grammarAccess.getWildcardRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleWildcard();

            state._fsp--;

             after(grammarAccess.getWildcardRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1126063
public final EObject entryRuleFullJvmFormalParameter() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleFullJvmFormalParameter = null;


        try {
            // InternalSARL.g:8251:63: (iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF )
            // InternalSARL.g:8252:2: iv_ruleFullJvmFormalParameter= ruleFullJvmFormalParameter EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getFullJvmFormalParameterRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleFullJvmFormalParameter=ruleFullJvmFormalParameter();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
306560
public final void entryRuleAbstractToken() throws RecognitionException {
        try {
            // InternalXtext.g:421:1: ( ruleAbstractToken EOF )
            // InternalXtext.g:422:1: ruleAbstractToken EOF
            {
             before(grammarAccess.getAbstractTokenRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractToken();

            state._fsp--;

             after(grammarAccess.getAbstractTokenRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
764288
public final void entryRuleNamedArgument() throws RecognitionException {
        try {
            // InternalXtext.g:571:1: ( ruleNamedArgument EOF )
            // InternalXtext.g:572:1: ruleNamedArgument EOF
            {
             before(grammarAccess.getNamedArgumentRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNamedArgument();

            state._fsp--;

             after(grammarAccess.getNamedArgumentRule()); 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

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