private bool preprocessor_expression_sempred(Preprocessor_expressionContext _localctx, int predIndex)
        {
            switch (predIndex)
            {
            case 0: return(Precpred(Context, 4));

            case 1: return(Precpred(Context, 3));

            case 2: return(Precpred(Context, 2));

            case 3: return(Precpred(Context, 1));
            }
            return(true);
        }
        private Preprocessor_expressionContext preprocessor_expression(int _p)
        {
            ParserRuleContext _parentctx             = Context;
            int _parentState                         = State;
            Preprocessor_expressionContext _localctx = new Preprocessor_expressionContext(Context, _parentState);
            Preprocessor_expressionContext _prevctx  = _localctx;
            int _startState = 4;

            EnterRecursionRule(_localctx, 4, RULE_preprocessor_expression, _p);
            try {
                int _alt;
                EnterOuterAlt(_localctx, 1);
                {
                    State = 95;
                    ErrorHandler.Sync(this);
                    switch (TokenStream.LA(1))
                    {
                    case TRUE:
                    {
                        State           = 80; Match(TRUE);
                        _localctx.value = "true";
                    }
                    break;

                    case FALSE:
                    {
                        State           = 82; Match(FALSE);
                        _localctx.value = "false";
                    }
                    break;

                    case CONDITIONAL_SYMBOL:
                    {
                        State           = 84; _localctx._CONDITIONAL_SYMBOL = Match(CONDITIONAL_SYMBOL);
                        _localctx.value = ConditionalSymbols.Contains((_localctx._CONDITIONAL_SYMBOL != null?_localctx._CONDITIONAL_SYMBOL.Text:null)) ? "true" : "false";
                    }
                    break;

                    case OPEN_PARENS:
                    {
                        State           = 86; Match(OPEN_PARENS);
                        State           = 87; _localctx.expr = preprocessor_expression(0);
                        State           = 88; Match(CLOSE_PARENS);
                        _localctx.value = _localctx.expr.value;
                    }
                    break;

                    case BANG:
                    {
                        State           = 91; Match(BANG);
                        State           = 92; _localctx.expr = preprocessor_expression(5);
                        _localctx.value = _localctx.expr.value == "true" ? "false" : "true";
                    }
                    break;

                    default:
                        throw new NoViableAltException(this);
                    }
                    Context.Stop = TokenStream.LT(-1);
                    State        = 119;
                    ErrorHandler.Sync(this);
                    _alt = Interpreter.AdaptivePredict(TokenStream, 7, Context);
                    while (_alt != 2 && _alt != global::Antlr4.Runtime.Atn.ATN.INVALID_ALT_NUMBER)
                    {
                        if (_alt == 1)
                        {
                            if (ParseListeners != null)
                            {
                                TriggerExitRuleEvent();
                            }
                            _prevctx = _localctx;
                            {
                                State = 117;
                                ErrorHandler.Sync(this);
                                switch (Interpreter.AdaptivePredict(TokenStream, 6, Context))
                                {
                                case 1:
                                {
                                    _localctx       = new Preprocessor_expressionContext(_parentctx, _parentState);
                                    _localctx.expr1 = _prevctx;
                                    PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
                                    State = 97;
                                    if (!(Precpred(Context, 4)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 4)");
                                    }
                                    State           = 98; Match(OP_EQ);
                                    State           = 99; _localctx.expr2 = preprocessor_expression(5);
                                    _localctx.value = (_localctx.expr1.value == _localctx.expr2.value ? "true" : "false");
                                }
                                break;

                                case 2:
                                {
                                    _localctx       = new Preprocessor_expressionContext(_parentctx, _parentState);
                                    _localctx.expr1 = _prevctx;
                                    PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
                                    State = 102;
                                    if (!(Precpred(Context, 3)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 3)");
                                    }
                                    State           = 103; Match(OP_NE);
                                    State           = 104; _localctx.expr2 = preprocessor_expression(4);
                                    _localctx.value = (_localctx.expr1.value != _localctx.expr2.value ? "true" : "false");
                                }
                                break;

                                case 3:
                                {
                                    _localctx       = new Preprocessor_expressionContext(_parentctx, _parentState);
                                    _localctx.expr1 = _prevctx;
                                    PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
                                    State = 107;
                                    if (!(Precpred(Context, 2)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 2)");
                                    }
                                    State           = 108; Match(OP_AND);
                                    State           = 109; _localctx.expr2 = preprocessor_expression(3);
                                    _localctx.value = (_localctx.expr1.value == "true" && _localctx.expr2.value == "true" ? "true" : "false");
                                }
                                break;

                                case 4:
                                {
                                    _localctx       = new Preprocessor_expressionContext(_parentctx, _parentState);
                                    _localctx.expr1 = _prevctx;
                                    PushNewRecursionContext(_localctx, _startState, RULE_preprocessor_expression);
                                    State = 112;
                                    if (!(Precpred(Context, 1)))
                                    {
                                        throw new FailedPredicateException(this, "Precpred(Context, 1)");
                                    }
                                    State           = 113; Match(OP_OR);
                                    State           = 114; _localctx.expr2 = preprocessor_expression(2);
                                    _localctx.value = (_localctx.expr1.value == "true" || _localctx.expr2.value == "true" ? "true" : "false");
                                }
                                break;
                                }
                            }
                        }
                        State = 121;
                        ErrorHandler.Sync(this);
                        _alt = Interpreter.AdaptivePredict(TokenStream, 7, Context);
                    }
                }
            }
            catch (RecognitionException re) {
                _localctx.exception = re;
                ErrorHandler.ReportError(this, re);
                ErrorHandler.Recover(this, re);
            }
            finally {
                UnrollRecursionContexts(_parentctx);
            }
            return(_localctx);
        }