InternalXtext.g:1420:1: entryRuleEnumLiterals : ruleEnumLiterals EOF ;
481017
public final void entryRuleEnumLiterals() throws RecognitionException {
        try {
            // InternalXtext.g:1421:1: ( ruleEnumLiterals EOF )
            // InternalXtext.g:1422:1: ruleEnumLiterals EOF
            {
             before(grammarAccess.getEnumLiteralsRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEnumLiterals();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1310998
public final void entryRuleXTypeLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:1384:1: ( ruleXTypeLiteral EOF )
            // InternalXbase.g:1385:1: ruleXTypeLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXTypeLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXTypeLiteral();

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

            }

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

        EObject iv_ruleLiteral = null;


        try {
            // InternalSimpleAntlr.g:1470:2: (iv_ruleLiteral= ruleLiteral EOF )
            // InternalSimpleAntlr.g:1471:2: iv_ruleLiteral= ruleLiteral EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleLiteral=ruleLiteral();

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

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
238674
public final void entryRuleXExpression() throws RecognitionException {
        try {
            // InternalXbase.g:59:1: ( ruleXExpression EOF )
            // InternalXbase.g:60:1: ruleXExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXExpression();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
297406
public final void entryRuleAlternatives() throws RecognitionException {
        try {
            // InternalXtext.g:321:1: ( ruleAlternatives EOF )
            // InternalXtext.g:322:1: ruleAlternatives EOF
            {
             before(grammarAccess.getAlternativesRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAlternatives();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
958213
public final void entryRuleEOF() throws RecognitionException {
        try {
            // InternalXtext.g:1346:1: ( ruleEOF EOF )
            // InternalXtext.g:1347:1: ruleEOF EOF
            {
             before(grammarAccess.getEOFRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleEOF();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
31275
public final void entryRuleValidID() throws RecognitionException {
        try {
            // InternalXbase.g:1867:1: ( ruleValidID EOF )
            // InternalXbase.g:1868:1: ruleValidID EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getValidIDRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleValidID();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
175741
public final void entryRuleXShortClosure() throws RecognitionException {
        try {
            // InternalXbase.g:834:1: ( ruleXShortClosure EOF )
            // InternalXbase.g:835:1: ruleXShortClosure EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXShortClosureRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXShortClosure();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
334993
public final void entryRuleXThrowExpression() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1534:1: ( ruleXThrowExpression EOF )
            // InternalXbaseWithAnnotations.g:1535:1: ruleXThrowExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXThrowExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXThrowExpression();

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

            }

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

        EObject iv_ruleRichStringLiteralStart = null;


        try {
            // InternalSARL.g:10858:63: (iv_ruleRichStringLiteralStart= ruleRichStringLiteralStart EOF )
            // InternalSARL.g:10859:2: iv_ruleRichStringLiteralStart= ruleRichStringLiteralStart EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getRichStringLiteralStartRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleRichStringLiteralStart=ruleRichStringLiteralStart();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
971400
public final void entryRuleXImportDeclaration() throws RecognitionException {
        try {
            // InternalXtype.g:384:1: ( ruleXImportDeclaration EOF )
            // InternalXtype.g:385:1: ruleXImportDeclaration EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXImportDeclarationRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXImportDeclaration();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1246290
public final void entryRuleXNumberLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:1334:1: ( ruleXNumberLiteral EOF )
            // InternalXbase.g:1335:1: ruleXNumberLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXNumberLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXNumberLiteral();

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

            }

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

        EObject iv_ruleAntlrGrammar = null;


        try {
            // InternalSimpleAntlr.g:74:2: (iv_ruleAntlrGrammar= ruleAntlrGrammar EOF )
            // InternalSimpleAntlr.g:75:2: iv_ruleAntlrGrammar= ruleAntlrGrammar EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getAntlrGrammarRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleAntlrGrammar=ruleAntlrGrammar();

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

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
240127
public final void entryRuleUnorderedGroup() throws RecognitionException {
        try {
            // InternalXtext.g:371:1: ( ruleUnorderedGroup EOF )
            // InternalXtext.g:372:1: ruleUnorderedGroup EOF
            {
             before(grammarAccess.getUnorderedGroupRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUnorderedGroup();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
925948
public final void entryRuleTerminalRule() throws RecognitionException {
        try {
            // InternalXtext.g:1096:1: ( ruleTerminalRule EOF )
            // InternalXtext.g:1097:1: ruleTerminalRule EOF
            {
             before(grammarAccess.getTerminalRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTerminalRule();

            state._fsp--;

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

            }

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

        EObject iv_ruleRichStringLiteral = null;


        try {
            // InternalSARL.g:10814:58: (iv_ruleRichStringLiteral= ruleRichStringLiteral EOF )
            // InternalSARL.g:10815:2: iv_ruleRichStringLiteral= ruleRichStringLiteral EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getRichStringLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleRichStringLiteral=ruleRichStringLiteral();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1241192
public final void entryRuleTerminalToken() throws RecognitionException {
        try {
            // InternalXtext.g:1171:1: ( ruleTerminalToken EOF )
            // InternalXtext.g:1172:1: ruleTerminalToken EOF
            {
             before(grammarAccess.getTerminalTokenRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleTerminalToken();

            state._fsp--;

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

            }

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