InternalXtext.g:645:1: entryRuleConjunction : ruleConjunction EOF ;
543346
public final void entryRuleConjunction() throws RecognitionException {
        try {
            // InternalXtext.g:646:1: ( ruleConjunction EOF )
            // InternalXtext.g:647:1: ruleConjunction EOF
            {
             before(grammarAccess.getConjunctionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleConjunction();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
660815
public final void entryRuleRuleCall() throws RecognitionException {
        try {
            // InternalXtext.g:546:1: ( ruleRuleCall EOF )
            // InternalXtext.g:547:1: ruleRuleCall EOF
            {
             before(grammarAccess.getRuleCallRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleRuleCall();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
207293
public final void entryRuleXCastedExpression() throws RecognitionException {
        try {
            // InternalXbase.g:559:1: ( ruleXCastedExpression EOF )
            // InternalXbase.g:560:1: ruleXCastedExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXCastedExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXCastedExpression();

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
737178
public final void entryRuleXUnaryOperation() throws RecognitionException {
        try {
            // InternalXbaseWithAnnotations.g:634:1: ( ruleXUnaryOperation EOF )
            // InternalXbaseWithAnnotations.g:635:1: ruleXUnaryOperation EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXUnaryOperationRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXUnaryOperation();

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

            }

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

        EObject iv_ruleDisjunction = null;


        try {
            // InternalXtext.g:1758:52: (iv_ruleDisjunction= ruleDisjunction EOF )
            // InternalXtext.g:1759:2: iv_ruleDisjunction= ruleDisjunction EOF
            {
             newCompositeNode(grammarAccess.getDisjunctionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleDisjunction=ruleDisjunction();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
1249356
public final void entryRuleAbstractTerminal() throws RecognitionException {
        try {
            // InternalXtext.g:496:1: ( ruleAbstractTerminal EOF )
            // InternalXtext.g:497:1: ruleAbstractTerminal EOF
            {
             before(grammarAccess.getAbstractTerminalRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleAbstractTerminal();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1003600
public final void entryRuleLiteralCondition() throws RecognitionException {
        try {
            // InternalXtext.g:596:1: ( ruleLiteralCondition EOF )
            // InternalXtext.g:597:1: ruleLiteralCondition EOF
            {
             before(grammarAccess.getLiteralConditionRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            ruleLiteralCondition();

            state._fsp--;

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

            }

        }
        catch (RecognitionException re) {
            reportError(re);
            recover(input,re);
        }
        finally {
        }
        return ;
    }
1104778
public final void entryRuleXParenthesizedExpression() throws RecognitionException {
        try {
            // InternalXbase.g:859:1: ( ruleXParenthesizedExpression EOF )
            // InternalXbase.g:860:1: ruleXParenthesizedExpression EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXParenthesizedExpressionRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXParenthesizedExpression();

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

            }

        }
        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 ;
    }
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 ;
    }
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 ;
    }
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 ;
    }
1261256
public final EObject ruleConjunction() throws RecognitionException {
        EObject current = null;

        Token otherlv_2=null;
        EObject this_Negation_0 = null;

        EObject lv_right_3_0 = null;



        	enterRule();

        try {
            // InternalXtext.g:1830:2: ( (this_Negation_0= ruleNegation ( () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) ) )* ) )
            // InternalXtext.g:1831:2: (this_Negation_0= ruleNegation ( () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) ) )* )
            {
            // InternalXtext.g:1831:2: (this_Negation_0= ruleNegation ( () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) ) )* )
            // InternalXtext.g:1832:3: this_Negation_0= ruleNegation ( () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) ) )*
            {

            			newCompositeNode(grammarAccess.getConjunctionAccess().getNegationParserRuleCall_0());
            		
            pushFollow(FollowSets000.FOLLOW_30);
            this_Negation_0=ruleNegation();

            state._fsp--;


            			current = this_Negation_0;
            			afterParserOrEnumRuleCall();
            		
            // InternalXtext.g:1840:3: ( () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) ) )*
            loop45:
            do {
                int alt45=2;
                int LA45_0 = input.LA(1);

                if ( (LA45_0==31) ) {
                    alt45=1;
                }


                switch (alt45) {
            	case 1 :
            	    // InternalXtext.g:1841:4: () otherlv_2= '&' ( (lv_right_3_0= ruleNegation ) )
            	    {
            	    // InternalXtext.g:1841:4: ()
            	    // InternalXtext.g:1842:5: 
            	    {

            	    					current = forceCreateModelElementAndSet(
            	    						grammarAccess.getConjunctionAccess().getConjunctionLeftAction_1_0(),
            	    						current);
            	    				

            	    }

            	    otherlv_2=(Token)match(input,31,FollowSets000.FOLLOW_26); 

            	    				newLeafNode(otherlv_2, grammarAccess.getConjunctionAccess().getAmpersandKeyword_1_1());
            	    			
            	    // InternalXtext.g:1852:4: ( (lv_right_3_0= ruleNegation ) )
            	    // InternalXtext.g:1853:5: (lv_right_3_0= ruleNegation )
            	    {
            	    // InternalXtext.g:1853:5: (lv_right_3_0= ruleNegation )
            	    // InternalXtext.g:1854:6: lv_right_3_0= ruleNegation
            	    {

            	    						newCompositeNode(grammarAccess.getConjunctionAccess().getRightNegationParserRuleCall_1_2_0());
            	    					
            	    pushFollow(FollowSets000.FOLLOW_30);
            	    lv_right_3_0=ruleNegation();

            	    state._fsp--;


            	    						if (current==null) {
            	    							current = createModelElementForParent(grammarAccess.getConjunctionRule());
            	    						}
            	    						set(
            	    							current,
            	    							"right",
            	    							lv_right_3_0,
            	    							"org.eclipse.xtext.Xtext.Negation");
            	    						afterParserOrEnumRuleCall();
            	    					

            	    }


            	    }


            	    }
            	    break;

            	default :
            	    break loop45;
                }
            } while (true);


            }


            }


            	leaveRule();

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
727463
public final EObject entryRuleAbstractRule() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleAbstractRule = null;


        try {
            // InternalXtext.g:298:53: (iv_ruleAbstractRule= ruleAbstractRule EOF )
            // InternalXtext.g:299:2: iv_ruleAbstractRule= ruleAbstractRule EOF
            {
             newCompositeNode(grammarAccess.getAbstractRuleRule()); 
            pushFollow(FollowSets000.FOLLOW_1);
            iv_ruleAbstractRule=ruleAbstractRule();

            state._fsp--;

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

            }

        }

            catch (RecognitionException re) {
                recover(input,re);
                appendSkippedTokens();
            }
        finally {
        }
        return current;
    }
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 ;
    }
172158
public final void entryRuleXSetLiteral() throws RecognitionException {
        try {
            // InternalXbase.g:734:1: ( ruleXSetLiteral EOF )
            // InternalXbase.g:735:1: ruleXSetLiteral EOF
            {
            if ( state.backtracking==0 ) {
               before(grammarAccess.getXSetLiteralRule()); 
            }
            pushFollow(FOLLOW_1);
            ruleXSetLiteral();

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

            }

        }
        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 ;
    }