InternalXtext.g:1270:1: entryRuleNegatedToken : ruleNegatedToken EOF ;
326020
public final void entryRuleNegatedToken() throws RecognitionException {
        try {
            // InternalXtext.g:1271:1: ( ruleNegatedToken EOF )
            // InternalXtext.g:1272:1: ruleNegatedToken EOF
            {
             before(grammarAccess.getNegatedTokenRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNegatedToken();

            state._fsp--;

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

            }

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

        EObject iv_ruleLiteralCondition = null;


        try {
            // InternalXtext.g:1711:57: (iv_ruleLiteralCondition= ruleLiteralCondition EOF )
            // InternalXtext.g:1712:2: iv_ruleLiteralCondition= ruleLiteralCondition EOF
            {
             newCompositeNode(grammarAccess.getLiteralConditionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleLiteralCondition=ruleLiteralCondition();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1256978
public final void entryRuleXTryCatchFinallyExpression() throws RecognitionException {
        try {
            // InternalXbase.g:1459:1: ( ruleXTryCatchFinallyExpression EOF )
            // InternalXbase.g:1460:1: ruleXTryCatchFinallyExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXTryCatchFinallyExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXTryCatchFinallyExpression();

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

            }

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

        AntlrDatatypeRuleToken iv_ruleOpPostfix = null;


        try {
            // InternalPureXbase.g:2245:49: (iv_ruleOpPostfix= ruleOpPostfix EOF )
            // InternalPureXbase.g:2246:2: iv_ruleOpPostfix= ruleOpPostfix EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getOpPostfixRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleOpPostfix=ruleOpPostfix();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
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 ;
    }
55241
public final void entryRuleUntilToken() throws RecognitionException {
        try {
            // InternalXtext.g:1296:1: ( ruleUntilToken EOF )
            // InternalXtext.g:1297:1: ruleUntilToken EOF
            {
             before(grammarAccess.getUntilTokenRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleUntilToken();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
685054
public final void entryRuleKeyword() throws RecognitionException {
        try {
            // InternalXtext.g:521:1: ( ruleKeyword EOF )
            // InternalXtext.g:522:1: ruleKeyword EOF
            {
             before(grammarAccess.getKeywordRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleKeyword();

            state._fsp--;

             after(grammarAccess.getKeywordRule()); 
            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 ;
    }
743567
public final String entryRuleOpOther() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleOpOther = null;


        try {
            // InternalXbase.g:945:47: (iv_ruleOpOther= ruleOpOther EOF )
            // InternalXbase.g:946:2: iv_ruleOpOther= ruleOpOther EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getOpOtherRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleOpOther=ruleOpOther();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
577633
public final void entryRuleParenthesizedElement() throws RecognitionException {
        try {
            // InternalXtext.g:1046:1: ( ruleParenthesizedElement EOF )
            // InternalXtext.g:1047:1: ruleParenthesizedElement EOF
            {
             before(grammarAccess.getParenthesizedElementRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParenthesizedElement();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
659886
public final void entryRuleXDoWhileExpression() throws RecognitionException {
        try {
            // InternalXbase.g:1034:1: ( ruleXDoWhileExpression EOF )
            // InternalXbase.g:1035:1: ruleXDoWhileExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXDoWhileExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXDoWhileExpression();

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

            }

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

        EObject iv_ruleEnumLiteralDeclaration = null;


        try {
            // InternalXtext.g:3700:63: (iv_ruleEnumLiteralDeclaration= ruleEnumLiteralDeclaration EOF )
            // InternalXtext.g:3701:2: iv_ruleEnumLiteralDeclaration= ruleEnumLiteralDeclaration EOF
            {
             newCompositeNode(grammarAccess.getEnumLiteralDeclarationRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleEnumLiteralDeclaration=ruleEnumLiteralDeclaration();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1172882
public final void ruleUntilToken() throws RecognitionException {

        		int stackSize = keepStackSize();
        	
        try {
            // InternalXtext.g:1308:2: ( ( ( rule__UntilToken__Group__0 ) ) )
            // InternalXtext.g:1309:2: ( ( rule__UntilToken__Group__0 ) )
            {
            // InternalXtext.g:1309:2: ( ( rule__UntilToken__Group__0 ) )
            // InternalXtext.g:1310:3: ( rule__UntilToken__Group__0 )
            {
             before(grammarAccess.getUntilTokenAccess().getGroup()); 
            // InternalXtext.g:1311:3: ( rule__UntilToken__Group__0 )
            // InternalXtext.g:1311:4: rule__UntilToken__Group__0
            {
            pushFollow(FollowSets000.FOLLOW_2);
            rule__UntilToken__Group__0();

            state._fsp--;


            }

             after(grammarAccess.getUntilTokenAccess().getGroup()); 

            }


            }

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

            	restoreStackSize(stackSize);

        }
        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 ;
    }
190959
public final void entryRuleOpPostfix() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:734:1: ( ruleOpPostfix EOF )
            // InternalXbaseWithAnnotations.g:735:1: ruleOpPostfix EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpPostfixRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpPostfix();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
58387
public final void entryRuleXCatchClause() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1634:1: ( ruleXCatchClause EOF )
            // InternalXbaseWithAnnotations.g:1635:1: ruleXCatchClause EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXCatchClauseRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXCatchClause();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXCatchClauseRule()); 
            }
            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 ;
    }