// $ANTLR start "additiveExpression"
    // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:481:1: additiveExpression : multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )* ;
    public HqlParser.additiveExpression_return additiveExpression() // throws RecognitionException [1]
    {   
        HqlParser.additiveExpression_return retval = new HqlParser.additiveExpression_return();
        retval.Start = input.LT(1);

        IASTNode root_0 = null;

        IToken PLUS187 = null;
        IToken MINUS188 = null;
        HqlParser.multiplyExpression_return multiplyExpression186 = default(HqlParser.multiplyExpression_return);

        HqlParser.multiplyExpression_return multiplyExpression189 = default(HqlParser.multiplyExpression_return);


        IASTNode PLUS187_tree=null;
        IASTNode MINUS188_tree=null;

        try 
    	{
            // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:2: ( multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )* )
            // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:4: multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )*
            {
            	root_0 = (IASTNode)adaptor.GetNilNode();

            	PushFollow(FOLLOW_multiplyExpression_in_additiveExpression2335);
            	multiplyExpression186 = multiplyExpression();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, multiplyExpression186.Tree);
            	// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:23: ( ( PLUS | MINUS ) multiplyExpression )*
            	do 
            	{
            	    int alt65 = 2;
            	    int LA65_0 = input.LA(1);

            	    if ( ((LA65_0 >= PLUS && LA65_0 <= MINUS)) )
            	    {
            	        alt65 = 1;
            	    }


            	    switch (alt65) 
            		{
            			case 1 :
            			    // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:25: ( PLUS | MINUS ) multiplyExpression
            			    {
            			    	// /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:25: ( PLUS | MINUS )
            			    	int alt64 = 2;
            			    	int LA64_0 = input.LA(1);

            			    	if ( (LA64_0 == PLUS) )
            			    	{
            			    	    alt64 = 1;
            			    	}
            			    	else if ( (LA64_0 == MINUS) )
            			    	{
            			    	    alt64 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    NoViableAltException nvae_d64s0 =
            			    	        new NoViableAltException("", 64, 0, input);

            			    	    throw nvae_d64s0;
            			    	}
            			    	switch (alt64) 
            			    	{
            			    	    case 1 :
            			    	        // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:27: PLUS
            			    	        {
            			    	        	PLUS187=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_additiveExpression2341); 
            			    	        		PLUS187_tree = (IASTNode)adaptor.Create(PLUS187);
            			    	        		root_0 = (IASTNode)adaptor.BecomeRoot(PLUS187_tree, root_0);


            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // /Users/Steve/Projects/NHibernate/Branches/2.1.x/nhibernate/src/NHibernate/Hql/Ast/ANTLR/Hql.g:482:35: MINUS
            			    	        {
            			    	        	MINUS188=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_additiveExpression2346); 
            			    	        		MINUS188_tree = (IASTNode)adaptor.Create(MINUS188);
            			    	        		root_0 = (IASTNode)adaptor.BecomeRoot(MINUS188_tree, root_0);


            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_multiplyExpression_in_additiveExpression2351);
            			    	multiplyExpression189 = multiplyExpression();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, multiplyExpression189.Tree);

            			    }
            			    break;

            			default:
            			    goto loop65;
            	    }
            	} while (true);

            	loop65:
            		;	// Stops C# compiler whining that label 'loop65' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (IASTNode)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (IASTNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }
    // $ANTLR start "additiveExpression"
    // Hql.g:499:1: additiveExpression : multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )* ;
    public HqlParser.additiveExpression_return additiveExpression() // throws RecognitionException [1]
    {   
        HqlParser.additiveExpression_return retval = new HqlParser.additiveExpression_return();
        retval.Start = input.LT(1);

        IASTNode root_0 = null;

        IToken PLUS200 = null;
        IToken MINUS201 = null;
        HqlParser.multiplyExpression_return multiplyExpression199 = default(HqlParser.multiplyExpression_return);

        HqlParser.multiplyExpression_return multiplyExpression202 = default(HqlParser.multiplyExpression_return);


        IASTNode PLUS200_tree=null;
        IASTNode MINUS201_tree=null;

        try 
    	{
            // Hql.g:500:2: ( multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )* )
            // Hql.g:500:4: multiplyExpression ( ( PLUS | MINUS ) multiplyExpression )*
            {
            	root_0 = (IASTNode)adaptor.GetNilNode();

            	PushFollow(FOLLOW_multiplyExpression_in_additiveExpression2433);
            	multiplyExpression199 = multiplyExpression();
            	state.followingStackPointer--;

            	adaptor.AddChild(root_0, multiplyExpression199.Tree);
            	// Hql.g:500:23: ( ( PLUS | MINUS ) multiplyExpression )*
            	do 
            	{
            	    int alt71 = 2;
            	    int LA71_0 = input.LA(1);

            	    if ( ((LA71_0 >= PLUS && LA71_0 <= MINUS)) )
            	    {
            	        alt71 = 1;
            	    }


            	    switch (alt71) 
            		{
            			case 1 :
            			    // Hql.g:500:25: ( PLUS | MINUS ) multiplyExpression
            			    {
            			    	// Hql.g:500:25: ( PLUS | MINUS )
            			    	int alt70 = 2;
            			    	int LA70_0 = input.LA(1);

            			    	if ( (LA70_0 == PLUS) )
            			    	{
            			    	    alt70 = 1;
            			    	}
            			    	else if ( (LA70_0 == MINUS) )
            			    	{
            			    	    alt70 = 2;
            			    	}
            			    	else 
            			    	{
            			    	    NoViableAltException nvae_d70s0 =
            			    	        new NoViableAltException("", 70, 0, input);

            			    	    throw nvae_d70s0;
            			    	}
            			    	switch (alt70) 
            			    	{
            			    	    case 1 :
            			    	        // Hql.g:500:27: PLUS
            			    	        {
            			    	        	PLUS200=(IToken)Match(input,PLUS,FOLLOW_PLUS_in_additiveExpression2439); 
            			    	        		PLUS200_tree = (IASTNode)adaptor.Create(PLUS200);
            			    	        		root_0 = (IASTNode)adaptor.BecomeRoot(PLUS200_tree, root_0);


            			    	        }
            			    	        break;
            			    	    case 2 :
            			    	        // Hql.g:500:35: MINUS
            			    	        {
            			    	        	MINUS201=(IToken)Match(input,MINUS,FOLLOW_MINUS_in_additiveExpression2444); 
            			    	        		MINUS201_tree = (IASTNode)adaptor.Create(MINUS201);
            			    	        		root_0 = (IASTNode)adaptor.BecomeRoot(MINUS201_tree, root_0);


            			    	        }
            			    	        break;

            			    	}

            			    	PushFollow(FOLLOW_multiplyExpression_in_additiveExpression2449);
            			    	multiplyExpression202 = multiplyExpression();
            			    	state.followingStackPointer--;

            			    	adaptor.AddChild(root_0, multiplyExpression202.Tree);

            			    }
            			    break;

            			default:
            			    goto loop71;
            	    }
            	} while (true);

            	loop71:
            		;	// Stops C# compiler whining that label 'loop71' has no statements


            }

            retval.Stop = input.LT(-1);

            	retval.Tree = (IASTNode)adaptor.RulePostProcessing(root_0);
            	adaptor.SetTokenBoundaries(retval.Tree, (IToken) retval.Start, (IToken) retval.Stop);
        }
        catch (RecognitionException re) 
    	{
            ReportError(re);
            Recover(input,re);
    	// Conversion of the second argument necessary, but harmless
    	retval.Tree = (IASTNode)adaptor.ErrorNode(input, (IToken) retval.Start, input.LT(-1), re);

        }
        finally 
    	{
        }
        return retval;
    }