InternalXtext.g:570:1: entryRuleNamedArgument : ruleNamedArgument EOF ;
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 ;
    }
1249356
public final void entryRuleAbstractTerminal() throws RecognitionException {
        try {
            // InternalXtext.g:496:1: ( ruleAbstractTerminal EOF )
            // InternalXtext.g:497:1: ruleAbstractTerminal EOF
            {
             before(grammarAccess.getAbstractTerminalRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractTerminal();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
320110
public final void entryRuleAssignment() throws RecognitionException {
        try {
            // InternalXtext.g:896:1: ( ruleAssignment EOF )
            // InternalXtext.g:897:1: ruleAssignment EOF
            {
             before(grammarAccess.getAssignmentRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAssignment();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
810335
public final String entryRuleQName() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleQName = null;


        try {
            // InternalSimpleAntlr.g:1616:2: (iv_ruleQName= ruleQName EOF )
            // InternalSimpleAntlr.g:1617:2: iv_ruleQName= ruleQName EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getQNameRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleQName=ruleQName();

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

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
640642
public final void entryRuleTypeRef() throws RecognitionException {
        try {
            // InternalXtext.g:296:1: ( ruleTypeRef EOF )
            // InternalXtext.g:297:1: ruleTypeRef EOF
            {
             before(grammarAccess.getTypeRefRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTypeRef();

            state._fsp--;

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

            }

        }
        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 ;
    }
915280
public final EObject entryRuleAction() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleAction = null;


        try {
            // InternalXtext.g:1346:47: (iv_ruleAction= ruleAction EOF )
            // InternalXtext.g:1347:2: iv_ruleAction= ruleAction EOF
            {
             newCompositeNode(grammarAccess.getActionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleAction=ruleAction();

            state._fsp--;

             current =iv_ruleAction; 
            match(input,EOF,FollowSets000.FOLLOW_2); 

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
59969
public final EObject entryRuleSarlScript() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleSarlScript = null;


        try {
            // InternalSARL.g:84:51: (iv_ruleSarlScript= ruleSarlScript EOF )
            // InternalSARL.g:85:2: iv_ruleSarlScript= ruleSarlScript EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getSarlScriptRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleSarlScript=ruleSarlScript();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1011889
public final void entryRuleOpMulti() throws RecognitionException {
        try {
            // InternalXbase.g:484:1: ( ruleOpMulti EOF )
            // InternalXbase.g:485:1: ruleOpMulti EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpMultiRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpMulti();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
620132
public final void entryRuleAbstractMetamodelDeclaration() throws RecognitionException {
        try {
            // InternalXtext.g:129:1: ( ruleAbstractMetamodelDeclaration EOF )
            // InternalXtext.g:130:1: ruleAbstractMetamodelDeclaration EOF
            {
             before(grammarAccess.getAbstractMetamodelDeclarationRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractMetamodelDeclaration();

            state._fsp--;

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

            }

        }
        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 ;
    }
210728
public final String entryRuleArgument() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleArgument = null;


        try {
            // InternalSimpleExpressions.g:721:2: (iv_ruleArgument= ruleArgument EOF )
            // InternalSimpleExpressions.g:722:2: iv_ruleArgument= ruleArgument EOF
            {
             newCompositeNode(grammarAccess.getArgumentRule()); 
            pushFollow(FOLLOW_1);
            iv_ruleArgument=ruleArgument();

            state._fsp--;

             current =iv_ruleArgument.getText(); 
            match(input,EOF,FOLLOW_2); 

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
549810
public final void entryRuleXBlockExpression() throws RecognitionException {
        try {
            // InternalXbase.g:1059:1: ( ruleXBlockExpression EOF )
            // InternalXbase.g:1060:1: ruleXBlockExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXBlockExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXBlockExpression();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
667169
public final void entryRuleAction() throws RecognitionException {
        try {
            // InternalXtext.g:471:1: ( ruleAction EOF )
            // InternalXtext.g:472:1: ruleAction EOF
            {
             before(grammarAccess.getActionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAction();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
486816
public final void entryRuleGrammarID() throws RecognitionException {
        try {
            // InternalXtext.g:79:1: ( ruleGrammarID EOF )
            // InternalXtext.g:80:1: ruleGrammarID EOF
            {
             before(grammarAccess.getGrammarIDRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleGrammarID();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1110811
public final void entryRuleXNullLiteral() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1434:1: ( ruleXNullLiteral EOF )
            // InternalXbaseWithAnnotations.g:1435:1: ruleXNullLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXNullLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXNullLiteral();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
621656
public final void entryRuleParenthesizedTerminalElement() throws RecognitionException {
        try {
            // InternalXtext.g:1221:1: ( ruleParenthesizedTerminalElement EOF )
            // InternalXtext.g:1222:1: ruleParenthesizedTerminalElement EOF
            {
             before(grammarAccess.getParenthesizedTerminalElementRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParenthesizedTerminalElement();

            state._fsp--;

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

            }

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