private ExpressionContext expression(int _p)
        {
            ParserRuleContext _parentctx = Context;
            int _parentState             = State;
            ExpressionContext _localctx  = new ExpressionContext(Context, _parentState);
            ExpressionContext _prevctx   = _localctx;
            int _startState = 16;

            EnterRecursionRule(_localctx, 16, RULE_expression, _p);
            try {
                int _alt;
                EnterOuterAlt(_localctx, 1);
                {
                    State = 80;
                    ErrorHandler.Sync(this);
                    switch (Interpreter.AdaptivePredict(TokenStream, 6, Context))
                    {
                    case 1:
                    {
                        State = 76; paraphrase();
                    }
                    break;

                    case 2:
                    {
                        State = 77; assignment();
                    }
                    break;

                    case 3:
                    {
                        State = 78; Match(NUMBER);
                    }
                    break;

                    case 4:
                    {
                        State = 79; Match(NAME);
                    }
                    break;
                    }
                    Context.Stop = TokenStream.LT(-1);
                    State        = 99;
                    ErrorHandler.Sync(this);
                    _alt = Interpreter.AdaptivePredict(TokenStream, 8, Context);
                    while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
                    {
                        if (_alt == 1)
                        {
                            if (ParseListeners != null)
                            {
                                TriggerExitRuleEvent();
                            }
                            _prevctx = _localctx;
                            {
                                State = 97;
                                ErrorHandler.Sync(this);
                                switch (Interpreter.AdaptivePredict(TokenStream, 7, Context))
                                {
                                case 1:
                                {
                                    _localctx = new ExpressionContext(_parentctx, _parentState);
                                    PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                    State = 82;
                                    if (!(Precpred(Context, 8)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 8)");
                                    }
                                    State = 83; Match(MULTIPLY);
                                    State = 84; expression(9);
                                }
                                break;

                                case 2:
                                {
                                    _localctx = new ExpressionContext(_parentctx, _parentState);
                                    PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                    State = 85;
                                    if (!(Precpred(Context, 7)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 7)");
                                    }
                                    State = 86; Match(DIVIDE);
                                    State = 87; expression(8);
                                }
                                break;

                                case 3:
                                {
                                    _localctx = new ExpressionContext(_parentctx, _parentState);
                                    PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                    State = 88;
                                    if (!(Precpred(Context, 6)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 6)");
                                    }
                                    State = 89; Match(MODULO);
                                    State = 90; expression(7);
                                }
                                break;

                                case 4:
                                {
                                    _localctx = new ExpressionContext(_parentctx, _parentState);
                                    PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                    State = 91;
                                    if (!(Precpred(Context, 5)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 5)");
                                    }
                                    State = 92; Match(ADD);
                                    State = 93; expression(6);
                                }
                                break;

                                case 5:
                                {
                                    _localctx = new ExpressionContext(_parentctx, _parentState);
                                    PushNewRecursionContext(_localctx, _startState, RULE_expression);
                                    State = 94;
                                    if (!(Precpred(Context, 4)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 4)");
                                    }
                                    State = 95; Match(SUBSTRACT);
                                    State = 96; expression(5);
                                }
                                break;
                                }
                            }
                        }
                        State = 101;
                        ErrorHandler.Sync(this);
                        _alt = Interpreter.AdaptivePredict(TokenStream, 8, Context);
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                UnrollRecursionContexts(_parentctx);
            }
            return(_localctx);
        }