// $ANTLR start "expression"
    // FastSimpleExpression.g3:49:0: public expression : additive_expression EOF ;
    public FastSimpleExpressionParser.expression_return expression()
    {
        FastSimpleExpressionParser.expression_return retval = new FastSimpleExpressionParser.expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        IToken EOF2 = null;

        FastSimpleExpressionParser.additive_expression_return additive_expression1 = default(FastSimpleExpressionParser.additive_expression_return);

        CommonTree EOF2_tree = null;

        try
        {
            // FastSimpleExpression.g3:50:4: ( additive_expression EOF )
            // FastSimpleExpression.g3:50:4: additive_expression EOF
            {
                root_0 = (CommonTree)adaptor.Nil();

                PushFollow(Follow._additive_expression_in_expression50);
                additive_expression1 = additive_expression();
                PopFollow();

                adaptor.AddChild(root_0, additive_expression1.Tree);
                EOF2      = (IToken)Match(input, EOF, Follow._EOF_in_expression54);
                EOF2_tree = (CommonTree)adaptor.Create(EOF2);
                adaptor.AddChild(root_0, EOF2_tree);
            }

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

            retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
        }
        catch (RecognitionException re)
        {
            ReportError(re);
            Recover(input, re);
            retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
        }
        finally
        {
        }
        return(retval);
    }
	// $ANTLR start "additive_expression"
	// FastSimpleExpression.g3:54:0: additive_expression : multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* ;
	private FastSimpleExpressionParser.additive_expression_return additive_expression()
	{
		FastSimpleExpressionParser.additive_expression_return retval = new FastSimpleExpressionParser.additive_expression_return();
		retval.start = input.LT(1);

		CommonTree root_0 = null;

		IToken char_literal4=null;
		IToken char_literal5=null;
		FastSimpleExpressionParser.multiplicative_expression_return multiplicative_expression3 = default(FastSimpleExpressionParser.multiplicative_expression_return);
		FastSimpleExpressionParser.multiplicative_expression_return multiplicative_expression6 = default(FastSimpleExpressionParser.multiplicative_expression_return);

		CommonTree char_literal4_tree=null;
		CommonTree char_literal5_tree=null;

		try
		{
			// FastSimpleExpression.g3:55:4: ( multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* )
			// FastSimpleExpression.g3:55:4: multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )*
			{
			root_0 = (CommonTree)adaptor.Nil();

			PushFollow(Follow._multiplicative_expression_in_additive_expression65);
			multiplicative_expression3=multiplicative_expression();
			PopFollow();

			adaptor.AddChild(root_0, multiplicative_expression3.Tree);
			// FastSimpleExpression.g3:56:3: ( ( '+' | '-' ) multiplicative_expression )*
			while (true)
			{
				int alt2=2;
				int LA2_0 = input.LA(1);

				if ((LA2_0==7||LA2_0==11))
				{
					alt2=1;
				}


				switch ( alt2 )
				{
				case 1:
					// FastSimpleExpression.g3:56:5: ( '+' | '-' ) multiplicative_expression
					{
					// FastSimpleExpression.g3:56:5: ( '+' | '-' )
					int alt1=2;
					int LA1_0 = input.LA(1);

					if ((LA1_0==11))
					{
						alt1=1;
					}
					else if ((LA1_0==7))
					{
						alt1=2;
					}
					else
					{
						NoViableAltException nvae = new NoViableAltException("", 1, 0, input);

						throw nvae;
					}
					switch (alt1)
					{
					case 1:
						// FastSimpleExpression.g3:56:6: '+'
						{
						char_literal4=(IToken)Match(input,11,Follow._11_in_additive_expression72); 
						char_literal4_tree = (CommonTree)adaptor.Create(char_literal4);
						root_0 = (CommonTree)adaptor.BecomeRoot(char_literal4_tree, root_0);


						}
						break;
					case 2:
						// FastSimpleExpression.g3:56:13: '-'
						{
						char_literal5=(IToken)Match(input,7,Follow._7_in_additive_expression77); 
						char_literal5_tree = (CommonTree)adaptor.Create(char_literal5);
						root_0 = (CommonTree)adaptor.BecomeRoot(char_literal5_tree, root_0);


						}
						break;

					}

					PushFollow(Follow._multiplicative_expression_in_additive_expression84);
					multiplicative_expression6=multiplicative_expression();
					PopFollow();

					adaptor.AddChild(root_0, multiplicative_expression6.Tree);

					}
					break;

				default:
					goto loop2;
				}
			}

			loop2:
				;



			}

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

			retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
			adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);

		}
		catch (RecognitionException re)
		{
			ReportError(re);
			Recover(input,re);
		retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);

		}
		finally
		{
		}
		return retval;

	}
    // $ANTLR start "additive_expression"
    // FastSimpleExpression.g3:54:0: additive_expression : multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* ;
    private FastSimpleExpressionParser.additive_expression_return additive_expression()
    {
        FastSimpleExpressionParser.additive_expression_return retval = new FastSimpleExpressionParser.additive_expression_return();
        retval.start = input.LT(1);

        CommonTree root_0 = null;

        IToken char_literal4 = null;
        IToken char_literal5 = null;

        FastSimpleExpressionParser.multiplicative_expression_return multiplicative_expression3 = default(FastSimpleExpressionParser.multiplicative_expression_return);
        FastSimpleExpressionParser.multiplicative_expression_return multiplicative_expression6 = default(FastSimpleExpressionParser.multiplicative_expression_return);

        CommonTree char_literal4_tree = null;
        CommonTree char_literal5_tree = null;

        try
        {
            // FastSimpleExpression.g3:55:4: ( multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )* )
            // FastSimpleExpression.g3:55:4: multiplicative_expression ( ( '+' | '-' ) multiplicative_expression )*
            {
                root_0 = (CommonTree)adaptor.Nil();

                PushFollow(Follow._multiplicative_expression_in_additive_expression65);
                multiplicative_expression3 = multiplicative_expression();
                PopFollow();

                adaptor.AddChild(root_0, multiplicative_expression3.Tree);
                // FastSimpleExpression.g3:56:3: ( ( '+' | '-' ) multiplicative_expression )*
                while (true)
                {
                    int alt2  = 2;
                    int LA2_0 = input.LA(1);

                    if ((LA2_0 == 7 || LA2_0 == 11))
                    {
                        alt2 = 1;
                    }


                    switch (alt2)
                    {
                    case 1:
                        // FastSimpleExpression.g3:56:5: ( '+' | '-' ) multiplicative_expression
                    {
                        // FastSimpleExpression.g3:56:5: ( '+' | '-' )
                        int alt1  = 2;
                        int LA1_0 = input.LA(1);

                        if ((LA1_0 == 11))
                        {
                            alt1 = 1;
                        }
                        else if ((LA1_0 == 7))
                        {
                            alt1 = 2;
                        }
                        else
                        {
                            NoViableAltException nvae = new NoViableAltException("", 1, 0, input);

                            throw nvae;
                        }
                        switch (alt1)
                        {
                        case 1:
                            // FastSimpleExpression.g3:56:6: '+'
                        {
                            char_literal4      = (IToken)Match(input, 11, Follow._11_in_additive_expression72);
                            char_literal4_tree = (CommonTree)adaptor.Create(char_literal4);
                            root_0             = (CommonTree)adaptor.BecomeRoot(char_literal4_tree, root_0);
                        }
                        break;

                        case 2:
                            // FastSimpleExpression.g3:56:13: '-'
                        {
                            char_literal5      = (IToken)Match(input, 7, Follow._7_in_additive_expression77);
                            char_literal5_tree = (CommonTree)adaptor.Create(char_literal5);
                            root_0             = (CommonTree)adaptor.BecomeRoot(char_literal5_tree, root_0);
                        }
                        break;
                        }

                        PushFollow(Follow._multiplicative_expression_in_additive_expression84);
                        multiplicative_expression6 = multiplicative_expression();
                        PopFollow();

                        adaptor.AddChild(root_0, multiplicative_expression6.Tree);
                    }
                    break;

                    default:
                        goto loop2;
                    }
                }

loop2:
                ;
            }

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

            retval.tree = (CommonTree)adaptor.RulePostProcessing(root_0);
            adaptor.SetTokenBoundaries(retval.tree, retval.start, retval.stop);
        }
        catch (RecognitionException re)
        {
            ReportError(re);
            Recover(input, re);
            retval.tree = (CommonTree)adaptor.ErrorNode(input, retval.start, input.LT(-1), re);
        }
        finally
        {
        }
        return(retval);
    }