// Generated from MXParser.g4 by ANTLR 4.13.2


#include "MXParserVisitor.h"

#include "MXParser.h"


using namespace antlrcpp;

using namespace antlr4;

namespace {

struct MXParserStaticData final {
  MXParserStaticData(std::vector<std::string> ruleNames,
                        std::vector<std::string> literalNames,
                        std::vector<std::string> symbolicNames)
      : ruleNames(std::move(ruleNames)), literalNames(std::move(literalNames)),
        symbolicNames(std::move(symbolicNames)),
        vocabulary(this->literalNames, this->symbolicNames) {}

  MXParserStaticData(const MXParserStaticData&) = delete;
  MXParserStaticData(MXParserStaticData&&) = delete;
  MXParserStaticData& operator=(const MXParserStaticData&) = delete;
  MXParserStaticData& operator=(MXParserStaticData&&) = delete;

  std::vector<antlr4::dfa::DFA> decisionToDFA;
  antlr4::atn::PredictionContextCache sharedContextCache;
  const std::vector<std::string> ruleNames;
  const std::vector<std::string> literalNames;
  const std::vector<std::string> symbolicNames;
  const antlr4::dfa::Vocabulary vocabulary;
  antlr4::atn::SerializedATNView serializedATN;
  std::unique_ptr<antlr4::atn::ATN> atn;
};

::antlr4::internal::OnceFlag mxparserParserOnceFlag;
#if ANTLR4_USE_THREAD_LOCAL_CACHE
static thread_local
#endif
std::unique_ptr<MXParserStaticData> mxparserParserStaticData = nullptr;

void mxparserParserInitialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  if (mxparserParserStaticData != nullptr) {
    return;
  }
#else
  assert(mxparserParserStaticData == nullptr);
#endif
  auto staticData = std::make_unique<MXParserStaticData>(
    std::vector<std::string>{
      "mxprog", "function", "type", "block", "statement", "expression", 
      "returnStmt", "ifStmt"
    },
    std::vector<std::string>{
      "", "'int'", "'void'", "'if'", "'else'", "'return'", "'+'", "'-'", 
      "'*'", "'/'", "'='", "'('", "')'", "'{'", "'}'", "';'"
    },
    std::vector<std::string>{
      "", "INT", "VOID", "IF", "ELSE", "RETURN", "PLUS", "MINUS", "MULTIPLY", 
      "DIVIDE", "ASSIGN", "LPAREN", "RPAREN", "LBRACE", "RBRACE", "SEMICOLON", 
      "ID", "INT_LITERAL", "WS", "COMMENT"
    }
  );
  static const int32_t serializedATNSegment[] = {
  	4,1,19,81,2,0,7,0,2,1,7,1,2,2,7,2,2,3,7,3,2,4,7,4,2,5,7,5,2,6,7,6,2,7,
  	7,7,1,0,5,0,18,8,0,10,0,12,0,21,9,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,1,1,1,
  	2,1,2,1,3,1,3,5,3,35,8,3,10,3,12,3,38,9,3,1,3,1,3,1,4,1,4,1,4,1,4,1,4,
  	3,4,47,8,4,1,5,1,5,1,5,1,5,1,5,1,5,1,5,3,5,56,8,5,1,5,1,5,1,5,5,5,61,
  	8,5,10,5,12,5,64,9,5,1,6,1,6,3,6,68,8,6,1,6,1,6,1,7,1,7,1,7,1,7,1,7,1,
  	7,1,7,3,7,79,8,7,1,7,0,1,10,8,0,2,4,6,8,10,12,14,0,2,1,0,1,2,1,0,6,9,
  	81,0,19,1,0,0,0,2,24,1,0,0,0,4,30,1,0,0,0,6,32,1,0,0,0,8,46,1,0,0,0,10,
  	55,1,0,0,0,12,65,1,0,0,0,14,71,1,0,0,0,16,18,3,2,1,0,17,16,1,0,0,0,18,
  	21,1,0,0,0,19,17,1,0,0,0,19,20,1,0,0,0,20,22,1,0,0,0,21,19,1,0,0,0,22,
  	23,5,0,0,1,23,1,1,0,0,0,24,25,3,4,2,0,25,26,5,16,0,0,26,27,5,11,0,0,27,
  	28,5,12,0,0,28,29,3,6,3,0,29,3,1,0,0,0,30,31,7,0,0,0,31,5,1,0,0,0,32,
  	36,5,13,0,0,33,35,3,8,4,0,34,33,1,0,0,0,35,38,1,0,0,0,36,34,1,0,0,0,36,
  	37,1,0,0,0,37,39,1,0,0,0,38,36,1,0,0,0,39,40,5,14,0,0,40,7,1,0,0,0,41,
  	42,3,10,5,0,42,43,5,15,0,0,43,47,1,0,0,0,44,47,3,12,6,0,45,47,3,14,7,
  	0,46,41,1,0,0,0,46,44,1,0,0,0,46,45,1,0,0,0,47,9,1,0,0,0,48,49,6,5,-1,
  	0,49,56,5,17,0,0,50,56,5,16,0,0,51,52,5,11,0,0,52,53,3,10,5,0,53,54,5,
  	12,0,0,54,56,1,0,0,0,55,48,1,0,0,0,55,50,1,0,0,0,55,51,1,0,0,0,56,62,
  	1,0,0,0,57,58,10,2,0,0,58,59,7,1,0,0,59,61,3,10,5,3,60,57,1,0,0,0,61,
  	64,1,0,0,0,62,60,1,0,0,0,62,63,1,0,0,0,63,11,1,0,0,0,64,62,1,0,0,0,65,
  	67,5,5,0,0,66,68,3,10,5,0,67,66,1,0,0,0,67,68,1,0,0,0,68,69,1,0,0,0,69,
  	70,5,15,0,0,70,13,1,0,0,0,71,72,5,3,0,0,72,73,5,11,0,0,73,74,3,10,5,0,
  	74,75,5,12,0,0,75,78,3,8,4,0,76,77,5,4,0,0,77,79,3,8,4,0,78,76,1,0,0,
  	0,78,79,1,0,0,0,79,15,1,0,0,0,7,19,36,46,55,62,67,78
  };
  staticData->serializedATN = antlr4::atn::SerializedATNView(serializedATNSegment, sizeof(serializedATNSegment) / sizeof(serializedATNSegment[0]));

  antlr4::atn::ATNDeserializer deserializer;
  staticData->atn = deserializer.deserialize(staticData->serializedATN);

  const size_t count = staticData->atn->getNumberOfDecisions();
  staticData->decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    staticData->decisionToDFA.emplace_back(staticData->atn->getDecisionState(i), i);
  }
  mxparserParserStaticData = std::move(staticData);
}

}

MXParser::MXParser(TokenStream *input) : MXParser(input, antlr4::atn::ParserATNSimulatorOptions()) {}

MXParser::MXParser(TokenStream *input, const antlr4::atn::ParserATNSimulatorOptions &options) : Parser(input) {
  MXParser::initialize();
  _interpreter = new atn::ParserATNSimulator(this, *mxparserParserStaticData->atn, mxparserParserStaticData->decisionToDFA, mxparserParserStaticData->sharedContextCache, options);
}

MXParser::~MXParser() {
  delete _interpreter;
}

const atn::ATN& MXParser::getATN() const {
  return *mxparserParserStaticData->atn;
}

std::string MXParser::getGrammarFileName() const {
  return "MXParser.g4";
}

const std::vector<std::string>& MXParser::getRuleNames() const {
  return mxparserParserStaticData->ruleNames;
}

const dfa::Vocabulary& MXParser::getVocabulary() const {
  return mxparserParserStaticData->vocabulary;
}

antlr4::atn::SerializedATNView MXParser::getSerializedATN() const {
  return mxparserParserStaticData->serializedATN;
}


//----------------- MxprogContext ------------------------------------------------------------------

MXParser::MxprogContext::MxprogContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::MxprogContext::EOF() {
  return getToken(MXParser::EOF, 0);
}

std::vector<MXParser::FunctionContext *> MXParser::MxprogContext::function() {
  return getRuleContexts<MXParser::FunctionContext>();
}

MXParser::FunctionContext* MXParser::MxprogContext::function(size_t i) {
  return getRuleContext<MXParser::FunctionContext>(i);
}


size_t MXParser::MxprogContext::getRuleIndex() const {
  return MXParser::RuleMxprog;
}


std::any MXParser::MxprogContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitMxprog(this);
  else
    return visitor->visitChildren(this);
}

MXParser::MxprogContext* MXParser::mxprog() {
  MxprogContext *_localctx = _tracker.createInstance<MxprogContext>(_ctx, getState());
  enterRule(_localctx, 0, MXParser::RuleMxprog);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(19);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while (_la == MXParser::INT

    || _la == MXParser::VOID) {
      setState(16);
      function();
      setState(21);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(22);
    match(MXParser::EOF);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- FunctionContext ------------------------------------------------------------------

MXParser::FunctionContext::FunctionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MXParser::TypeContext* MXParser::FunctionContext::type() {
  return getRuleContext<MXParser::TypeContext>(0);
}

tree::TerminalNode* MXParser::FunctionContext::ID() {
  return getToken(MXParser::ID, 0);
}

tree::TerminalNode* MXParser::FunctionContext::LPAREN() {
  return getToken(MXParser::LPAREN, 0);
}

tree::TerminalNode* MXParser::FunctionContext::RPAREN() {
  return getToken(MXParser::RPAREN, 0);
}

MXParser::BlockContext* MXParser::FunctionContext::block() {
  return getRuleContext<MXParser::BlockContext>(0);
}


size_t MXParser::FunctionContext::getRuleIndex() const {
  return MXParser::RuleFunction;
}


std::any MXParser::FunctionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitFunction(this);
  else
    return visitor->visitChildren(this);
}

MXParser::FunctionContext* MXParser::function() {
  FunctionContext *_localctx = _tracker.createInstance<FunctionContext>(_ctx, getState());
  enterRule(_localctx, 2, MXParser::RuleFunction);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(24);
    type();
    setState(25);
    match(MXParser::ID);
    setState(26);
    match(MXParser::LPAREN);
    setState(27);
    match(MXParser::RPAREN);
    setState(28);
    block();
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- TypeContext ------------------------------------------------------------------

MXParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::TypeContext::INT() {
  return getToken(MXParser::INT, 0);
}

tree::TerminalNode* MXParser::TypeContext::VOID() {
  return getToken(MXParser::VOID, 0);
}


size_t MXParser::TypeContext::getRuleIndex() const {
  return MXParser::RuleType;
}


std::any MXParser::TypeContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitType(this);
  else
    return visitor->visitChildren(this);
}

MXParser::TypeContext* MXParser::type() {
  TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());
  enterRule(_localctx, 4, MXParser::RuleType);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(30);
    _la = _input->LA(1);
    if (!(_la == MXParser::INT

    || _la == MXParser::VOID)) {
    _errHandler->recoverInline(this);
    }
    else {
      _errHandler->reportMatch(this);
      consume();
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- BlockContext ------------------------------------------------------------------

MXParser::BlockContext::BlockContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::BlockContext::LBRACE() {
  return getToken(MXParser::LBRACE, 0);
}

tree::TerminalNode* MXParser::BlockContext::RBRACE() {
  return getToken(MXParser::RBRACE, 0);
}

std::vector<MXParser::StatementContext *> MXParser::BlockContext::statement() {
  return getRuleContexts<MXParser::StatementContext>();
}

MXParser::StatementContext* MXParser::BlockContext::statement(size_t i) {
  return getRuleContext<MXParser::StatementContext>(i);
}


size_t MXParser::BlockContext::getRuleIndex() const {
  return MXParser::RuleBlock;
}


std::any MXParser::BlockContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitBlock(this);
  else
    return visitor->visitChildren(this);
}

MXParser::BlockContext* MXParser::block() {
  BlockContext *_localctx = _tracker.createInstance<BlockContext>(_ctx, getState());
  enterRule(_localctx, 6, MXParser::RuleBlock);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(32);
    match(MXParser::LBRACE);
    setState(36);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 198696) != 0)) {
      setState(33);
      statement();
      setState(38);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
    setState(39);
    match(MXParser::RBRACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- StatementContext ------------------------------------------------------------------

MXParser::StatementContext::StatementContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

MXParser::ExpressionContext* MXParser::StatementContext::expression() {
  return getRuleContext<MXParser::ExpressionContext>(0);
}

tree::TerminalNode* MXParser::StatementContext::SEMICOLON() {
  return getToken(MXParser::SEMICOLON, 0);
}

MXParser::ReturnStmtContext* MXParser::StatementContext::returnStmt() {
  return getRuleContext<MXParser::ReturnStmtContext>(0);
}

MXParser::IfStmtContext* MXParser::StatementContext::ifStmt() {
  return getRuleContext<MXParser::IfStmtContext>(0);
}


size_t MXParser::StatementContext::getRuleIndex() const {
  return MXParser::RuleStatement;
}


std::any MXParser::StatementContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitStatement(this);
  else
    return visitor->visitChildren(this);
}

MXParser::StatementContext* MXParser::statement() {
  StatementContext *_localctx = _tracker.createInstance<StatementContext>(_ctx, getState());
  enterRule(_localctx, 8, MXParser::RuleStatement);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    setState(46);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MXParser::LPAREN:
      case MXParser::ID:
      case MXParser::INT_LITERAL: {
        enterOuterAlt(_localctx, 1);
        setState(41);
        expression(0);
        setState(42);
        match(MXParser::SEMICOLON);
        break;
      }

      case MXParser::RETURN: {
        enterOuterAlt(_localctx, 2);
        setState(44);
        returnStmt();
        break;
      }

      case MXParser::IF: {
        enterOuterAlt(_localctx, 3);
        setState(45);
        ifStmt();
        break;
      }

    default:
      throw NoViableAltException(this);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ExpressionContext ------------------------------------------------------------------

MXParser::ExpressionContext::ExpressionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::ExpressionContext::INT_LITERAL() {
  return getToken(MXParser::INT_LITERAL, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::ID() {
  return getToken(MXParser::ID, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::LPAREN() {
  return getToken(MXParser::LPAREN, 0);
}

std::vector<MXParser::ExpressionContext *> MXParser::ExpressionContext::expression() {
  return getRuleContexts<MXParser::ExpressionContext>();
}

MXParser::ExpressionContext* MXParser::ExpressionContext::expression(size_t i) {
  return getRuleContext<MXParser::ExpressionContext>(i);
}

tree::TerminalNode* MXParser::ExpressionContext::RPAREN() {
  return getToken(MXParser::RPAREN, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::PLUS() {
  return getToken(MXParser::PLUS, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::MINUS() {
  return getToken(MXParser::MINUS, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::MULTIPLY() {
  return getToken(MXParser::MULTIPLY, 0);
}

tree::TerminalNode* MXParser::ExpressionContext::DIVIDE() {
  return getToken(MXParser::DIVIDE, 0);
}


size_t MXParser::ExpressionContext::getRuleIndex() const {
  return MXParser::RuleExpression;
}


std::any MXParser::ExpressionContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitExpression(this);
  else
    return visitor->visitChildren(this);
}


MXParser::ExpressionContext* MXParser::expression() {
   return expression(0);
}

MXParser::ExpressionContext* MXParser::expression(int precedence) {
  ParserRuleContext *parentContext = _ctx;
  size_t parentState = getState();
  MXParser::ExpressionContext *_localctx = _tracker.createInstance<ExpressionContext>(_ctx, parentState);
  MXParser::ExpressionContext *previousContext = _localctx;
  (void)previousContext; // Silence compiler, in case the context is not used by generated code.
  size_t startState = 10;
  enterRecursionRule(_localctx, 10, MXParser::RuleExpression, precedence);

    size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    unrollRecursionContexts(parentContext);
  });
  try {
    size_t alt;
    enterOuterAlt(_localctx, 1);
    setState(55);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case MXParser::INT_LITERAL: {
        setState(49);
        match(MXParser::INT_LITERAL);
        break;
      }

      case MXParser::ID: {
        setState(50);
        match(MXParser::ID);
        break;
      }

      case MXParser::LPAREN: {
        setState(51);
        match(MXParser::LPAREN);
        setState(52);
        expression(0);
        setState(53);
        match(MXParser::RPAREN);
        break;
      }

    default:
      throw NoViableAltException(this);
    }
    _ctx->stop = _input->LT(-1);
    setState(62);
    _errHandler->sync(this);
    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx);
    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {
      if (alt == 1) {
        if (!_parseListeners.empty())
          triggerExitRuleEvent();
        previousContext = _localctx;
        _localctx = _tracker.createInstance<ExpressionContext>(parentContext, parentState);
        pushNewRecursionContext(_localctx, startState, RuleExpression);
        setState(57);

        if (!(precpred(_ctx, 2))) throw FailedPredicateException(this, "precpred(_ctx, 2)");
        setState(58);
        _la = _input->LA(1);
        if (!((((_la & ~ 0x3fULL) == 0) &&
          ((1ULL << _la) & 960) != 0))) {
        _errHandler->recoverInline(this);
        }
        else {
          _errHandler->reportMatch(this);
          consume();
        }
        setState(59);
        expression(3); 
      }
      setState(64);
      _errHandler->sync(this);
      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 4, _ctx);
    }
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }
  return _localctx;
}

//----------------- ReturnStmtContext ------------------------------------------------------------------

MXParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::ReturnStmtContext::RETURN() {
  return getToken(MXParser::RETURN, 0);
}

tree::TerminalNode* MXParser::ReturnStmtContext::SEMICOLON() {
  return getToken(MXParser::SEMICOLON, 0);
}

MXParser::ExpressionContext* MXParser::ReturnStmtContext::expression() {
  return getRuleContext<MXParser::ExpressionContext>(0);
}


size_t MXParser::ReturnStmtContext::getRuleIndex() const {
  return MXParser::RuleReturnStmt;
}


std::any MXParser::ReturnStmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitReturnStmt(this);
  else
    return visitor->visitChildren(this);
}

MXParser::ReturnStmtContext* MXParser::returnStmt() {
  ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());
  enterRule(_localctx, 12, MXParser::RuleReturnStmt);
  size_t _la = 0;

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(65);
    match(MXParser::RETURN);
    setState(67);
    _errHandler->sync(this);

    _la = _input->LA(1);
    if ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & 198656) != 0)) {
      setState(66);
      expression(0);
    }
    setState(69);
    match(MXParser::SEMICOLON);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- IfStmtContext ------------------------------------------------------------------

MXParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* MXParser::IfStmtContext::IF() {
  return getToken(MXParser::IF, 0);
}

tree::TerminalNode* MXParser::IfStmtContext::LPAREN() {
  return getToken(MXParser::LPAREN, 0);
}

MXParser::ExpressionContext* MXParser::IfStmtContext::expression() {
  return getRuleContext<MXParser::ExpressionContext>(0);
}

tree::TerminalNode* MXParser::IfStmtContext::RPAREN() {
  return getToken(MXParser::RPAREN, 0);
}

std::vector<MXParser::StatementContext *> MXParser::IfStmtContext::statement() {
  return getRuleContexts<MXParser::StatementContext>();
}

MXParser::StatementContext* MXParser::IfStmtContext::statement(size_t i) {
  return getRuleContext<MXParser::StatementContext>(i);
}

tree::TerminalNode* MXParser::IfStmtContext::ELSE() {
  return getToken(MXParser::ELSE, 0);
}


size_t MXParser::IfStmtContext::getRuleIndex() const {
  return MXParser::RuleIfStmt;
}


std::any MXParser::IfStmtContext::accept(tree::ParseTreeVisitor *visitor) {
  if (auto parserVisitor = dynamic_cast<MXParserVisitor*>(visitor))
    return parserVisitor->visitIfStmt(this);
  else
    return visitor->visitChildren(this);
}

MXParser::IfStmtContext* MXParser::ifStmt() {
  IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());
  enterRule(_localctx, 14, MXParser::RuleIfStmt);

#if __cplusplus > 201703L
  auto onExit = finally([=, this] {
#else
  auto onExit = finally([=] {
#endif
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(71);
    match(MXParser::IF);
    setState(72);
    match(MXParser::LPAREN);
    setState(73);
    expression(0);
    setState(74);
    match(MXParser::RPAREN);
    setState(75);
    statement();
    setState(78);
    _errHandler->sync(this);

    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 6, _ctx)) {
    case 1: {
      setState(76);
      match(MXParser::ELSE);
      setState(77);
      statement();
      break;
    }

    default:
      break;
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

bool MXParser::sempred(RuleContext *context, size_t ruleIndex, size_t predicateIndex) {
  switch (ruleIndex) {
    case 5: return expressionSempred(antlrcpp::downCast<ExpressionContext *>(context), predicateIndex);

  default:
    break;
  }
  return true;
}

bool MXParser::expressionSempred(ExpressionContext *_localctx, size_t predicateIndex) {
  switch (predicateIndex) {
    case 0: return precpred(_ctx, 2);

  default:
    break;
  }
  return true;
}

void MXParser::initialize() {
#if ANTLR4_USE_THREAD_LOCAL_CACHE
  mxparserParserInitialize();
#else
  ::antlr4::internal::call_once(mxparserParserOnceFlag, mxparserParserInitialize);
#endif
}