InternalXbase.g:1233:1: entryRuleIdOrSuper : ruleIdOrSuper EOF ;
972888
public final void entryRuleIdOrSuper() throws RecognitionException {
        try {
            // InternalXbase.g:1234:1: ( ruleIdOrSuper EOF )
            // InternalXbase.g:1235:1: ruleIdOrSuper EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getIdOrSuperRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleIdOrSuper();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
278184
public final void entryRuleXAdditiveExpression() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:534:1: ( ruleXAdditiveExpression EOF )
            // InternalXbaseWithAnnotations.g:535:1: ruleXAdditiveExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXAdditiveExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXAdditiveExpression();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
883045
public final void entryRuleNegation() throws RecognitionException {
        try {
            // InternalXtext.g:671:1: ( ruleNegation EOF )
            // InternalXtext.g:672:1: ruleNegation EOF
            {
             before(grammarAccess.getNegationRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleNegation();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1214737
public final void entryRuleAtom() throws RecognitionException {
        try {
            // InternalXtext.g:696:1: ( ruleAtom EOF )
            // InternalXtext.g:697:1: ruleAtom EOF
            {
             before(grammarAccess.getAtomRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAtom();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
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 ;
    }
1317514
public final void entryRuleDisjunction() throws RecognitionException {
        try {
            // InternalXtext.g:621:1: ( ruleDisjunction EOF )
            // InternalXtext.g:622:1: ruleDisjunction EOF
            {
             before(grammarAccess.getDisjunctionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleDisjunction();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
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 ;
    }
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 ;
    }
669905
public final void entryRuleRuleID() throws RecognitionException {
        try {
            // InternalXtext.g:796:1: ( ruleRuleID EOF )
            // InternalXtext.g:797:1: ruleRuleID EOF
            {
             before(grammarAccess.getRuleIDRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleRuleID();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1349066
public final void entryRulePredicatedRuleCall() throws RecognitionException {
        try {
            // InternalXtext.g:871:1: ( rulePredicatedRuleCall EOF )
            // InternalXtext.g:872:1: rulePredicatedRuleCall EOF
            {
             before(grammarAccess.getPredicatedRuleCallRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            rulePredicatedRuleCall();

            state._fsp--;

             after(grammarAccess.getPredicatedRuleCallRule()); 
            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 ;
    }
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 ;
    }
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 ;
    }
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 ;
    }
1093090
public final void entryRuleOpAdd() throws RecognitionException {
        try {
            // InternalXbase.g:434:1: ( ruleOpAdd EOF )
            // InternalXbase.g:435:1: ruleOpAdd EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpAddRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpAdd();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
897260
public final void entryRuleFullJvmFormalParameter() throws RecognitionException {
        try {
            // InternalXbase.g:1159:1: ( ruleFullJvmFormalParameter EOF )
            // InternalXbase.g:1160:1: ruleFullJvmFormalParameter EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getFullJvmFormalParameterRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleFullJvmFormalParameter();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
348309
public final void entryRuleOpOr() throws RecognitionException {
        try {
            // InternalXbase.g:184:1: ( ruleOpOr EOF )
            // InternalXbase.g:185:1: ruleOpOr EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpOrRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpOr();

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

            }

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