InternalXbase.g:183:1: entryRuleOpOr : ruleOpOr EOF ;
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 ;
    }
759614
public final void entryRuleXAnnotationElementValue() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:134:1: ( ruleXAnnotationElementValue EOF )
            // InternalXbaseWithAnnotations.g:135:1: ruleXAnnotationElementValue EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXAnnotationElementValueRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXAnnotationElementValue();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
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 ;
    }
535018
public final void entryRuleXAssignment() throws RecognitionException {
        try {
            // InternalXbase.g:84:1: ( ruleXAssignment EOF )
            // InternalXbase.g:85:1: ruleXAssignment EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXAssignmentRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXAssignment();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXAssignmentRule()); 
            }
            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 ;
    }
966681
public final EObject entryRuleEOF() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleEOF = null;


        try {
            // InternalXtext.g:3437:44: (iv_ruleEOF= ruleEOF EOF )
            // InternalXtext.g:3438:2: iv_ruleEOF= ruleEOF EOF
            {
             newCompositeNode(grammarAccess.getEOFRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleEOF=ruleEOF();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
588764
public final void entryRuleParserRule() throws RecognitionException {
        try {
            // InternalXtext.g:229:1: ( ruleParserRule EOF )
            // InternalXtext.g:230:1: ruleParserRule EOF
            {
             before(grammarAccess.getParserRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleParserRule();

            state._fsp--;

             after(grammarAccess.getParserRuleRule()); 
            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 ;
    }
1063264
public final void entryRuleOpSingleAssign() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:234:1: ( ruleOpSingleAssign EOF )
            // InternalXbaseWithAnnotations.g:235:1: ruleOpSingleAssign EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpSingleAssignRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpSingleAssign();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
733838
public final void entryRuleJvmFormalParameter() throws RecognitionException {
        try {
            // InternalXbase.g:1134:1: ( ruleJvmFormalParameter EOF )
            // InternalXbase.g:1135:1: ruleJvmFormalParameter EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getJvmFormalParameterRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleJvmFormalParameter();

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

            }

        }
        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 ;
    }
87901
public final void entryRuleOpEquality() throws RecognitionException {
        try {
            // InternalXbase.g:284:1: ( ruleOpEquality EOF )
            // InternalXbase.g:285:1: ruleOpEquality EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpEqualityRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpEquality();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
176802
public final void entryRuleGrammar() throws RecognitionException {
        try {
            // InternalXtext.g:54:1: ( ruleGrammar EOF )
            // InternalXtext.g:55:1: ruleGrammar EOF
            {
             before(grammarAccess.getGrammarRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleGrammar();

            state._fsp--;

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

            }

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

        EObject iv_ruleModel = null;


        try {
            // InternalPureXbase.g:64:46: (iv_ruleModel= ruleModel EOF )
            // InternalPureXbase.g:65:2: iv_ruleModel= ruleModel EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getModelRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleModel=ruleModel();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1220016
public final void entryRuleXForLoopExpression() throws RecognitionException {
        try {
            // InternalXbase.g:959:1: ( ruleXForLoopExpression EOF )
            // InternalXbase.g:960:1: ruleXForLoopExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXForLoopExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXForLoopExpression();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
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 ;
    }
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 ;
    }