InternalXbase.g:133:1: entryRuleOpMultiAssign : ruleOpMultiAssign EOF ;
483740
public final void entryRuleOpMultiAssign() throws RecognitionException {
        try {
            // InternalXbase.g:134:1: ( ruleOpMultiAssign EOF )
            // InternalXbase.g:135:1: ruleOpMultiAssign EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getOpMultiAssignRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleOpMultiAssign();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
851112
public final void entryRuleXSwitchExpression() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:1034:1: ( ruleXSwitchExpression EOF )
            // InternalXbaseWithAnnotations.g:1035:1: ruleXSwitchExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXSwitchExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXSwitchExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXSwitchExpressionRule()); 
            }
            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 ;
    }
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 ;
    }
52691
public final String entryRuleOpSingleAssign() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleOpSingleAssign = null;


        try {
            // InternalPureXbase.g:906:54: (iv_ruleOpSingleAssign= ruleOpSingleAssign EOF )
            // InternalPureXbase.g:907:2: iv_ruleOpSingleAssign= ruleOpSingleAssign EOF
            {
            if ( state.backtracking==0 ) {
               newCompositeNode(grammarAccess.getOpSingleAssignRule()); 
            }
            pushFollow(FOLLOW_1);
            iv_ruleOpSingleAssign=ruleOpSingleAssign();

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1299986
public final void entryRuleNumber() throws RecognitionException {
         
        	HiddenTokens myHiddenTokenState = ((XtextTokenStream)input).setHiddenTokens();

        try {
            // InternalXbase.g:1562:1: ( ruleNumber EOF )
            // InternalXbase.g:1563:1: ruleNumber EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getNumberRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleNumber();

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

            }

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

            	myHiddenTokenState.restore();

        }
        return ;
    }
76730
public final EObject entryRuleNegation() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleNegation = null;


        try {
            // InternalXtext.g:1876:49: (iv_ruleNegation= ruleNegation EOF )
            // InternalXtext.g:1877:2: iv_ruleNegation= ruleNegation EOF
            {
             newCompositeNode(grammarAccess.getNegationRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleNegation=ruleNegation();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
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 ;
    }
408976
public final void entryRuleXBooleanLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:1284:1: ( ruleXBooleanLiteral EOF )
            // InternalXbase.g:1285:1: ruleXBooleanLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXBooleanLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXBooleanLiteral();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1247011
public final void entryRuleQualifiedNameInStaticImport() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:2042:1: ( ruleQualifiedNameInStaticImport EOF )
            // InternalXbaseWithAnnotations.g:2043:1: ruleQualifiedNameInStaticImport EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getQualifiedNameInStaticImportRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleQualifiedNameInStaticImport();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
969664
public final void entryRuleXEqualityExpression() throws RecognitionException {
        try {
            // InternalXbase.g:259:1: ( ruleXEqualityExpression EOF )
            // InternalXbase.g:260:1: ruleXEqualityExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXEqualityExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXEqualityExpression();

            state._fsp--;
            if (state.failed) return ;
            if ( state.backtracking==0 ) {
               after(grammarAccess.getXEqualityExpressionRule()); 
            }
            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 ;
    }
113879
public final void entryRuleXStringLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:1359:1: ( ruleXStringLiteral EOF )
            // InternalXbase.g:1360:1: ruleXStringLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXStringLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXStringLiteral();

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

            }

        }
        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 ;
    }
111610
public final void entryRuleAssignableTerminal() throws RecognitionException {
        try {
            // InternalXtext.g:921:1: ( ruleAssignableTerminal EOF )
            // InternalXtext.g:922:1: ruleAssignableTerminal EOF
            {
             before(grammarAccess.getAssignableTerminalRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAssignableTerminal();

            state._fsp--;

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

            }

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