
// Generated from SV3_1aSplitterParser.g4 by ANTLR 4.7.2


#include "SV3_1aSplitterParserListener.h"

#include "SV3_1aSplitterParser.h"


using namespace antlrcpp;
using namespace antlr4;

SV3_1aSplitterParser::SV3_1aSplitterParser(TokenStream *input) : Parser(input) {
  _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);
}

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

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

const std::vector<std::string>& SV3_1aSplitterParser::getRuleNames() const {
  return _ruleNames;
}

dfa::Vocabulary& SV3_1aSplitterParser::getVocabulary() const {
  return _vocabulary;
}


//----------------- Source_textContext ------------------------------------------------------------------

SV3_1aSplitterParser::Source_textContext::Source_textContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

std::vector<SV3_1aSplitterParser::DescriptionContext *> SV3_1aSplitterParser::Source_textContext::description() {
  return getRuleContexts<SV3_1aSplitterParser::DescriptionContext>();
}

SV3_1aSplitterParser::DescriptionContext* SV3_1aSplitterParser::Source_textContext::description(size_t i) {
  return getRuleContext<SV3_1aSplitterParser::DescriptionContext>(i);
}


size_t SV3_1aSplitterParser::Source_textContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleSource_text;
}

void SV3_1aSplitterParser::Source_textContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSource_text(this);
}

void SV3_1aSplitterParser::Source_textContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSource_text(this);
}

SV3_1aSplitterParser::Source_textContext* SV3_1aSplitterParser::source_text() {
  Source_textContext *_localctx = _tracker.createInstance<Source_textContext>(_ctx, getState());
  enterRule(_localctx, 0, SV3_1aSplitterParser::RuleSource_text);
  size_t _la = 0;

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(37);
    _errHandler->sync(this);
    _la = _input->LA(1);
    while ((((_la & ~ 0x3fULL) == 0) &&
      ((1ULL << _la) & ((1ULL << SV3_1aSplitterParser::MODULE)
      | (1ULL << SV3_1aSplitterParser::ENDMODULE)
      | (1ULL << SV3_1aSplitterParser::INTERFACE)
      | (1ULL << SV3_1aSplitterParser::ENDINTERFACE)
      | (1ULL << SV3_1aSplitterParser::PROGRAM)
      | (1ULL << SV3_1aSplitterParser::ENDPROGRAM)
      | (1ULL << SV3_1aSplitterParser::PRIMITIVE)
      | (1ULL << SV3_1aSplitterParser::ENDPRIMITIVE)
      | (1ULL << SV3_1aSplitterParser::PACKAGE)
      | (1ULL << SV3_1aSplitterParser::ENDPACKAGE)
      | (1ULL << SV3_1aSplitterParser::CHECKER)
      | (1ULL << SV3_1aSplitterParser::ENDCHECKER)
      | (1ULL << SV3_1aSplitterParser::CONFIG)
      | (1ULL << SV3_1aSplitterParser::ENDCONFIG)
      | (1ULL << SV3_1aSplitterParser::ANY))) != 0)) {
      setState(34);
      description();
      setState(39);
      _errHandler->sync(this);
      _la = _input->LA(1);
    }
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- DescriptionContext ------------------------------------------------------------------

SV3_1aSplitterParser::DescriptionContext::DescriptionContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

SV3_1aSplitterParser::ModuleContext* SV3_1aSplitterParser::DescriptionContext::module() {
  return getRuleContext<SV3_1aSplitterParser::ModuleContext>(0);
}

SV3_1aSplitterParser::EndmoduleContext* SV3_1aSplitterParser::DescriptionContext::endmodule() {
  return getRuleContext<SV3_1aSplitterParser::EndmoduleContext>(0);
}

SV3_1aSplitterParser::Sv_interfaceContext* SV3_1aSplitterParser::DescriptionContext::sv_interface() {
  return getRuleContext<SV3_1aSplitterParser::Sv_interfaceContext>(0);
}

SV3_1aSplitterParser::EndinterfaceContext* SV3_1aSplitterParser::DescriptionContext::endinterface() {
  return getRuleContext<SV3_1aSplitterParser::EndinterfaceContext>(0);
}

SV3_1aSplitterParser::ProgramContext* SV3_1aSplitterParser::DescriptionContext::program() {
  return getRuleContext<SV3_1aSplitterParser::ProgramContext>(0);
}

SV3_1aSplitterParser::EndprogramContext* SV3_1aSplitterParser::DescriptionContext::endprogram() {
  return getRuleContext<SV3_1aSplitterParser::EndprogramContext>(0);
}

SV3_1aSplitterParser::PrimitiveContext* SV3_1aSplitterParser::DescriptionContext::primitive() {
  return getRuleContext<SV3_1aSplitterParser::PrimitiveContext>(0);
}

SV3_1aSplitterParser::EndprimitiveContext* SV3_1aSplitterParser::DescriptionContext::endprimitive() {
  return getRuleContext<SV3_1aSplitterParser::EndprimitiveContext>(0);
}

SV3_1aSplitterParser::Sv_packageContext* SV3_1aSplitterParser::DescriptionContext::sv_package() {
  return getRuleContext<SV3_1aSplitterParser::Sv_packageContext>(0);
}

SV3_1aSplitterParser::EndpackageContext* SV3_1aSplitterParser::DescriptionContext::endpackage() {
  return getRuleContext<SV3_1aSplitterParser::EndpackageContext>(0);
}

SV3_1aSplitterParser::CheckerContext* SV3_1aSplitterParser::DescriptionContext::checker() {
  return getRuleContext<SV3_1aSplitterParser::CheckerContext>(0);
}

SV3_1aSplitterParser::EndcheckerContext* SV3_1aSplitterParser::DescriptionContext::endchecker() {
  return getRuleContext<SV3_1aSplitterParser::EndcheckerContext>(0);
}

SV3_1aSplitterParser::ConfigContext* SV3_1aSplitterParser::DescriptionContext::config() {
  return getRuleContext<SV3_1aSplitterParser::ConfigContext>(0);
}

SV3_1aSplitterParser::EndconfigContext* SV3_1aSplitterParser::DescriptionContext::endconfig() {
  return getRuleContext<SV3_1aSplitterParser::EndconfigContext>(0);
}

tree::TerminalNode* SV3_1aSplitterParser::DescriptionContext::ANY() {
  return getToken(SV3_1aSplitterParser::ANY, 0);
}


size_t SV3_1aSplitterParser::DescriptionContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleDescription;
}

void SV3_1aSplitterParser::DescriptionContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterDescription(this);
}

void SV3_1aSplitterParser::DescriptionContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitDescription(this);
}

SV3_1aSplitterParser::DescriptionContext* SV3_1aSplitterParser::description() {
  DescriptionContext *_localctx = _tracker.createInstance<DescriptionContext>(_ctx, getState());
  enterRule(_localctx, 2, SV3_1aSplitterParser::RuleDescription);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    setState(55);
    _errHandler->sync(this);
    switch (_input->LA(1)) {
      case SV3_1aSplitterParser::MODULE: {
        enterOuterAlt(_localctx, 1);
        setState(40);
        module();
        break;
      }

      case SV3_1aSplitterParser::ENDMODULE: {
        enterOuterAlt(_localctx, 2);
        setState(41);
        endmodule();
        break;
      }

      case SV3_1aSplitterParser::INTERFACE: {
        enterOuterAlt(_localctx, 3);
        setState(42);
        sv_interface();
        break;
      }

      case SV3_1aSplitterParser::ENDINTERFACE: {
        enterOuterAlt(_localctx, 4);
        setState(43);
        endinterface();
        break;
      }

      case SV3_1aSplitterParser::PROGRAM: {
        enterOuterAlt(_localctx, 5);
        setState(44);
        program();
        break;
      }

      case SV3_1aSplitterParser::ENDPROGRAM: {
        enterOuterAlt(_localctx, 6);
        setState(45);
        endprogram();
        break;
      }

      case SV3_1aSplitterParser::PRIMITIVE: {
        enterOuterAlt(_localctx, 7);
        setState(46);
        primitive();
        break;
      }

      case SV3_1aSplitterParser::ENDPRIMITIVE: {
        enterOuterAlt(_localctx, 8);
        setState(47);
        endprimitive();
        break;
      }

      case SV3_1aSplitterParser::PACKAGE: {
        enterOuterAlt(_localctx, 9);
        setState(48);
        sv_package();
        break;
      }

      case SV3_1aSplitterParser::ENDPACKAGE: {
        enterOuterAlt(_localctx, 10);
        setState(49);
        endpackage();
        break;
      }

      case SV3_1aSplitterParser::CHECKER: {
        enterOuterAlt(_localctx, 11);
        setState(50);
        checker();
        break;
      }

      case SV3_1aSplitterParser::ENDCHECKER: {
        enterOuterAlt(_localctx, 12);
        setState(51);
        endchecker();
        break;
      }

      case SV3_1aSplitterParser::CONFIG: {
        enterOuterAlt(_localctx, 13);
        setState(52);
        config();
        break;
      }

      case SV3_1aSplitterParser::ENDCONFIG: {
        enterOuterAlt(_localctx, 14);
        setState(53);
        endconfig();
        break;
      }

      case SV3_1aSplitterParser::ANY: {
        enterOuterAlt(_localctx, 15);
        setState(54);
        match(SV3_1aSplitterParser::ANY);
        break;
      }

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

  return _localctx;
}

//----------------- ModuleContext ------------------------------------------------------------------

SV3_1aSplitterParser::ModuleContext::ModuleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::ModuleContext::MODULE() {
  return getToken(SV3_1aSplitterParser::MODULE, 0);
}


size_t SV3_1aSplitterParser::ModuleContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleModule;
}

void SV3_1aSplitterParser::ModuleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterModule(this);
}

void SV3_1aSplitterParser::ModuleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitModule(this);
}

SV3_1aSplitterParser::ModuleContext* SV3_1aSplitterParser::module() {
  ModuleContext *_localctx = _tracker.createInstance<ModuleContext>(_ctx, getState());
  enterRule(_localctx, 4, SV3_1aSplitterParser::RuleModule);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(57);
    match(SV3_1aSplitterParser::MODULE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndmoduleContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndmoduleContext::EndmoduleContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndmoduleContext::ENDMODULE() {
  return getToken(SV3_1aSplitterParser::ENDMODULE, 0);
}


size_t SV3_1aSplitterParser::EndmoduleContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndmodule;
}

void SV3_1aSplitterParser::EndmoduleContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndmodule(this);
}

void SV3_1aSplitterParser::EndmoduleContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndmodule(this);
}

SV3_1aSplitterParser::EndmoduleContext* SV3_1aSplitterParser::endmodule() {
  EndmoduleContext *_localctx = _tracker.createInstance<EndmoduleContext>(_ctx, getState());
  enterRule(_localctx, 6, SV3_1aSplitterParser::RuleEndmodule);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(59);
    match(SV3_1aSplitterParser::ENDMODULE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Sv_interfaceContext ------------------------------------------------------------------

SV3_1aSplitterParser::Sv_interfaceContext::Sv_interfaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::Sv_interfaceContext::INTERFACE() {
  return getToken(SV3_1aSplitterParser::INTERFACE, 0);
}


size_t SV3_1aSplitterParser::Sv_interfaceContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleSv_interface;
}

void SV3_1aSplitterParser::Sv_interfaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSv_interface(this);
}

void SV3_1aSplitterParser::Sv_interfaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSv_interface(this);
}

SV3_1aSplitterParser::Sv_interfaceContext* SV3_1aSplitterParser::sv_interface() {
  Sv_interfaceContext *_localctx = _tracker.createInstance<Sv_interfaceContext>(_ctx, getState());
  enterRule(_localctx, 8, SV3_1aSplitterParser::RuleSv_interface);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(61);
    match(SV3_1aSplitterParser::INTERFACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndinterfaceContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndinterfaceContext::EndinterfaceContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndinterfaceContext::ENDINTERFACE() {
  return getToken(SV3_1aSplitterParser::ENDINTERFACE, 0);
}


size_t SV3_1aSplitterParser::EndinterfaceContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndinterface;
}

void SV3_1aSplitterParser::EndinterfaceContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndinterface(this);
}

void SV3_1aSplitterParser::EndinterfaceContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndinterface(this);
}

SV3_1aSplitterParser::EndinterfaceContext* SV3_1aSplitterParser::endinterface() {
  EndinterfaceContext *_localctx = _tracker.createInstance<EndinterfaceContext>(_ctx, getState());
  enterRule(_localctx, 10, SV3_1aSplitterParser::RuleEndinterface);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(63);
    match(SV3_1aSplitterParser::ENDINTERFACE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ProgramContext ------------------------------------------------------------------

SV3_1aSplitterParser::ProgramContext::ProgramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::ProgramContext::PROGRAM() {
  return getToken(SV3_1aSplitterParser::PROGRAM, 0);
}


size_t SV3_1aSplitterParser::ProgramContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleProgram;
}

void SV3_1aSplitterParser::ProgramContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterProgram(this);
}

void SV3_1aSplitterParser::ProgramContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitProgram(this);
}

SV3_1aSplitterParser::ProgramContext* SV3_1aSplitterParser::program() {
  ProgramContext *_localctx = _tracker.createInstance<ProgramContext>(_ctx, getState());
  enterRule(_localctx, 12, SV3_1aSplitterParser::RuleProgram);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(65);
    match(SV3_1aSplitterParser::PROGRAM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndprogramContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndprogramContext::EndprogramContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndprogramContext::ENDPROGRAM() {
  return getToken(SV3_1aSplitterParser::ENDPROGRAM, 0);
}


size_t SV3_1aSplitterParser::EndprogramContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndprogram;
}

void SV3_1aSplitterParser::EndprogramContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndprogram(this);
}

void SV3_1aSplitterParser::EndprogramContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndprogram(this);
}

SV3_1aSplitterParser::EndprogramContext* SV3_1aSplitterParser::endprogram() {
  EndprogramContext *_localctx = _tracker.createInstance<EndprogramContext>(_ctx, getState());
  enterRule(_localctx, 14, SV3_1aSplitterParser::RuleEndprogram);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(67);
    match(SV3_1aSplitterParser::ENDPROGRAM);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- PrimitiveContext ------------------------------------------------------------------

SV3_1aSplitterParser::PrimitiveContext::PrimitiveContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::PrimitiveContext::PRIMITIVE() {
  return getToken(SV3_1aSplitterParser::PRIMITIVE, 0);
}


size_t SV3_1aSplitterParser::PrimitiveContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RulePrimitive;
}

void SV3_1aSplitterParser::PrimitiveContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterPrimitive(this);
}

void SV3_1aSplitterParser::PrimitiveContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitPrimitive(this);
}

SV3_1aSplitterParser::PrimitiveContext* SV3_1aSplitterParser::primitive() {
  PrimitiveContext *_localctx = _tracker.createInstance<PrimitiveContext>(_ctx, getState());
  enterRule(_localctx, 16, SV3_1aSplitterParser::RulePrimitive);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(69);
    match(SV3_1aSplitterParser::PRIMITIVE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndprimitiveContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndprimitiveContext::EndprimitiveContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndprimitiveContext::ENDPRIMITIVE() {
  return getToken(SV3_1aSplitterParser::ENDPRIMITIVE, 0);
}


size_t SV3_1aSplitterParser::EndprimitiveContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndprimitive;
}

void SV3_1aSplitterParser::EndprimitiveContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndprimitive(this);
}

void SV3_1aSplitterParser::EndprimitiveContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndprimitive(this);
}

SV3_1aSplitterParser::EndprimitiveContext* SV3_1aSplitterParser::endprimitive() {
  EndprimitiveContext *_localctx = _tracker.createInstance<EndprimitiveContext>(_ctx, getState());
  enterRule(_localctx, 18, SV3_1aSplitterParser::RuleEndprimitive);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(71);
    match(SV3_1aSplitterParser::ENDPRIMITIVE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- Sv_packageContext ------------------------------------------------------------------

SV3_1aSplitterParser::Sv_packageContext::Sv_packageContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::Sv_packageContext::PACKAGE() {
  return getToken(SV3_1aSplitterParser::PACKAGE, 0);
}


size_t SV3_1aSplitterParser::Sv_packageContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleSv_package;
}

void SV3_1aSplitterParser::Sv_packageContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterSv_package(this);
}

void SV3_1aSplitterParser::Sv_packageContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitSv_package(this);
}

SV3_1aSplitterParser::Sv_packageContext* SV3_1aSplitterParser::sv_package() {
  Sv_packageContext *_localctx = _tracker.createInstance<Sv_packageContext>(_ctx, getState());
  enterRule(_localctx, 20, SV3_1aSplitterParser::RuleSv_package);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(73);
    match(SV3_1aSplitterParser::PACKAGE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndpackageContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndpackageContext::EndpackageContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndpackageContext::ENDPACKAGE() {
  return getToken(SV3_1aSplitterParser::ENDPACKAGE, 0);
}


size_t SV3_1aSplitterParser::EndpackageContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndpackage;
}

void SV3_1aSplitterParser::EndpackageContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndpackage(this);
}

void SV3_1aSplitterParser::EndpackageContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndpackage(this);
}

SV3_1aSplitterParser::EndpackageContext* SV3_1aSplitterParser::endpackage() {
  EndpackageContext *_localctx = _tracker.createInstance<EndpackageContext>(_ctx, getState());
  enterRule(_localctx, 22, SV3_1aSplitterParser::RuleEndpackage);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(75);
    match(SV3_1aSplitterParser::ENDPACKAGE);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- CheckerContext ------------------------------------------------------------------

SV3_1aSplitterParser::CheckerContext::CheckerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::CheckerContext::CHECKER() {
  return getToken(SV3_1aSplitterParser::CHECKER, 0);
}


size_t SV3_1aSplitterParser::CheckerContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleChecker;
}

void SV3_1aSplitterParser::CheckerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterChecker(this);
}

void SV3_1aSplitterParser::CheckerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitChecker(this);
}

SV3_1aSplitterParser::CheckerContext* SV3_1aSplitterParser::checker() {
  CheckerContext *_localctx = _tracker.createInstance<CheckerContext>(_ctx, getState());
  enterRule(_localctx, 24, SV3_1aSplitterParser::RuleChecker);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(77);
    match(SV3_1aSplitterParser::CHECKER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndcheckerContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndcheckerContext::EndcheckerContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndcheckerContext::ENDCHECKER() {
  return getToken(SV3_1aSplitterParser::ENDCHECKER, 0);
}


size_t SV3_1aSplitterParser::EndcheckerContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndchecker;
}

void SV3_1aSplitterParser::EndcheckerContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndchecker(this);
}

void SV3_1aSplitterParser::EndcheckerContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndchecker(this);
}

SV3_1aSplitterParser::EndcheckerContext* SV3_1aSplitterParser::endchecker() {
  EndcheckerContext *_localctx = _tracker.createInstance<EndcheckerContext>(_ctx, getState());
  enterRule(_localctx, 26, SV3_1aSplitterParser::RuleEndchecker);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(79);
    match(SV3_1aSplitterParser::ENDCHECKER);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- ConfigContext ------------------------------------------------------------------

SV3_1aSplitterParser::ConfigContext::ConfigContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::ConfigContext::CONFIG() {
  return getToken(SV3_1aSplitterParser::CONFIG, 0);
}


size_t SV3_1aSplitterParser::ConfigContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleConfig;
}

void SV3_1aSplitterParser::ConfigContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterConfig(this);
}

void SV3_1aSplitterParser::ConfigContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitConfig(this);
}

SV3_1aSplitterParser::ConfigContext* SV3_1aSplitterParser::config() {
  ConfigContext *_localctx = _tracker.createInstance<ConfigContext>(_ctx, getState());
  enterRule(_localctx, 28, SV3_1aSplitterParser::RuleConfig);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(81);
    match(SV3_1aSplitterParser::CONFIG);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- EndconfigContext ------------------------------------------------------------------

SV3_1aSplitterParser::EndconfigContext::EndconfigContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::EndconfigContext::ENDCONFIG() {
  return getToken(SV3_1aSplitterParser::ENDCONFIG, 0);
}


size_t SV3_1aSplitterParser::EndconfigContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleEndconfig;
}

void SV3_1aSplitterParser::EndconfigContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterEndconfig(this);
}

void SV3_1aSplitterParser::EndconfigContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitEndconfig(this);
}

SV3_1aSplitterParser::EndconfigContext* SV3_1aSplitterParser::endconfig() {
  EndconfigContext *_localctx = _tracker.createInstance<EndconfigContext>(_ctx, getState());
  enterRule(_localctx, 30, SV3_1aSplitterParser::RuleEndconfig);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(83);
    match(SV3_1aSplitterParser::ENDCONFIG);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

//----------------- AnyContext ------------------------------------------------------------------

SV3_1aSplitterParser::AnyContext::AnyContext(ParserRuleContext *parent, size_t invokingState)
  : ParserRuleContext(parent, invokingState) {
}

tree::TerminalNode* SV3_1aSplitterParser::AnyContext::ANY() {
  return getToken(SV3_1aSplitterParser::ANY, 0);
}


size_t SV3_1aSplitterParser::AnyContext::getRuleIndex() const {
  return SV3_1aSplitterParser::RuleAny;
}

void SV3_1aSplitterParser::AnyContext::enterRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->enterAny(this);
}

void SV3_1aSplitterParser::AnyContext::exitRule(tree::ParseTreeListener *listener) {
  auto parserListener = dynamic_cast<SV3_1aSplitterParserListener *>(listener);
  if (parserListener != nullptr)
    parserListener->exitAny(this);
}

SV3_1aSplitterParser::AnyContext* SV3_1aSplitterParser::any() {
  AnyContext *_localctx = _tracker.createInstance<AnyContext>(_ctx, getState());
  enterRule(_localctx, 32, SV3_1aSplitterParser::RuleAny);

  auto onExit = finally([=] {
    exitRule();
  });
  try {
    enterOuterAlt(_localctx, 1);
    setState(85);
    match(SV3_1aSplitterParser::ANY);
   
  }
  catch (RecognitionException &e) {
    _errHandler->reportError(this, e);
    _localctx->exception = std::current_exception();
    _errHandler->recover(this, _localctx->exception);
  }

  return _localctx;
}

// Static vars and initialization.
std::vector<dfa::DFA> SV3_1aSplitterParser::_decisionToDFA;
atn::PredictionContextCache SV3_1aSplitterParser::_sharedContextCache;

// We own the ATN which in turn owns the ATN states.
atn::ATN SV3_1aSplitterParser::_atn;
std::vector<uint16_t> SV3_1aSplitterParser::_serializedATN;

std::vector<std::string> SV3_1aSplitterParser::_ruleNames = {
  "source_text", "description", "module", "endmodule", "sv_interface", "endinterface", 
  "program", "endprogram", "primitive", "endprimitive", "sv_package", "endpackage", 
  "checker", "endchecker", "config", "endconfig", "any"
};

std::vector<std::string> SV3_1aSplitterParser::_literalNames = {
  "", "", "", "'module'", "'endmodule'", "'interface'", "'endinterface'", 
  "'program'", "'endprogram'", "'primivite'", "'endprimitive'", "'package'", 
  "'endpackage'", "'checker'", "'endchecker'", "'config'", "'endconfig'"
};

std::vector<std::string> SV3_1aSplitterParser::_symbolicNames = {
  "", "One_line_comment", "Block_comment", "MODULE", "ENDMODULE", "INTERFACE", 
  "ENDINTERFACE", "PROGRAM", "ENDPROGRAM", "PRIMITIVE", "ENDPRIMITIVE", 
  "PACKAGE", "ENDPACKAGE", "CHECKER", "ENDCHECKER", "CONFIG", "ENDCONFIG", 
  "String", "Spaces", "CR", "ANY"
};

dfa::Vocabulary SV3_1aSplitterParser::_vocabulary(_literalNames, _symbolicNames);

std::vector<std::string> SV3_1aSplitterParser::_tokenNames;

SV3_1aSplitterParser::Initializer::Initializer() {
	for (size_t i = 0; i < _symbolicNames.size(); ++i) {
		std::string name = _vocabulary.getLiteralName(i);
		if (name.empty()) {
			name = _vocabulary.getSymbolicName(i);
		}

		if (name.empty()) {
			_tokenNames.push_back("<INVALID>");
		} else {
      _tokenNames.push_back(name);
    }
	}

  _serializedATN = {
    0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 
    0x3, 0x16, 0x5a, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 0x9, 
    0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 0x7, 0x4, 
    0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 0x4, 0xb, 0x9, 
    0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 0xe, 0x9, 0xe, 0x4, 
    0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, 0x9, 0x11, 0x4, 0x12, 
    0x9, 0x12, 0x3, 0x2, 0x7, 0x2, 0x26, 0xa, 0x2, 0xc, 0x2, 0xe, 0x2, 0x29, 
    0xb, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 
    0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 
    0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x3a, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 
    0x5, 0x3, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 
    0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 
    0xc, 0x3, 0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 
    0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 
    0x3, 0x12, 0x2, 0x2, 0x13, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 
    0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x2, 0x2, 0x2, 
    0x57, 0x2, 0x27, 0x3, 0x2, 0x2, 0x2, 0x4, 0x39, 0x3, 0x2, 0x2, 0x2, 
    0x6, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x8, 0x3d, 0x3, 0x2, 0x2, 0x2, 0xa, 0x3f, 
    0x3, 0x2, 0x2, 0x2, 0xc, 0x41, 0x3, 0x2, 0x2, 0x2, 0xe, 0x43, 0x3, 0x2, 
    0x2, 0x2, 0x10, 0x45, 0x3, 0x2, 0x2, 0x2, 0x12, 0x47, 0x3, 0x2, 0x2, 
    0x2, 0x14, 0x49, 0x3, 0x2, 0x2, 0x2, 0x16, 0x4b, 0x3, 0x2, 0x2, 0x2, 
    0x18, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x1c, 
    0x51, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x53, 0x3, 0x2, 0x2, 0x2, 0x20, 0x55, 
    0x3, 0x2, 0x2, 0x2, 0x22, 0x57, 0x3, 0x2, 0x2, 0x2, 0x24, 0x26, 0x5, 
    0x4, 0x3, 0x2, 0x25, 0x24, 0x3, 0x2, 0x2, 0x2, 0x26, 0x29, 0x3, 0x2, 
    0x2, 0x2, 0x27, 0x25, 0x3, 0x2, 0x2, 0x2, 0x27, 0x28, 0x3, 0x2, 0x2, 
    0x2, 0x28, 0x3, 0x3, 0x2, 0x2, 0x2, 0x29, 0x27, 0x3, 0x2, 0x2, 0x2, 
    0x2a, 0x3a, 0x5, 0x6, 0x4, 0x2, 0x2b, 0x3a, 0x5, 0x8, 0x5, 0x2, 0x2c, 
    0x3a, 0x5, 0xa, 0x6, 0x2, 0x2d, 0x3a, 0x5, 0xc, 0x7, 0x2, 0x2e, 0x3a, 
    0x5, 0xe, 0x8, 0x2, 0x2f, 0x3a, 0x5, 0x10, 0x9, 0x2, 0x30, 0x3a, 0x5, 
    0x12, 0xa, 0x2, 0x31, 0x3a, 0x5, 0x14, 0xb, 0x2, 0x32, 0x3a, 0x5, 0x16, 
    0xc, 0x2, 0x33, 0x3a, 0x5, 0x18, 0xd, 0x2, 0x34, 0x3a, 0x5, 0x1a, 0xe, 
    0x2, 0x35, 0x3a, 0x5, 0x1c, 0xf, 0x2, 0x36, 0x3a, 0x5, 0x1e, 0x10, 0x2, 
    0x37, 0x3a, 0x5, 0x20, 0x11, 0x2, 0x38, 0x3a, 0x7, 0x16, 0x2, 0x2, 0x39, 
    0x2a, 0x3, 0x2, 0x2, 0x2, 0x39, 0x2b, 0x3, 0x2, 0x2, 0x2, 0x39, 0x2c, 
    0x3, 0x2, 0x2, 0x2, 0x39, 0x2d, 0x3, 0x2, 0x2, 0x2, 0x39, 0x2e, 0x3, 
    0x2, 0x2, 0x2, 0x39, 0x2f, 0x3, 0x2, 0x2, 0x2, 0x39, 0x30, 0x3, 0x2, 
    0x2, 0x2, 0x39, 0x31, 0x3, 0x2, 0x2, 0x2, 0x39, 0x32, 0x3, 0x2, 0x2, 
    0x2, 0x39, 0x33, 0x3, 0x2, 0x2, 0x2, 0x39, 0x34, 0x3, 0x2, 0x2, 0x2, 
    0x39, 0x35, 0x3, 0x2, 0x2, 0x2, 0x39, 0x36, 0x3, 0x2, 0x2, 0x2, 0x39, 
    0x37, 0x3, 0x2, 0x2, 0x2, 0x39, 0x38, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x5, 
    0x3, 0x2, 0x2, 0x2, 0x3b, 0x3c, 0x7, 0x5, 0x2, 0x2, 0x3c, 0x7, 0x3, 
    0x2, 0x2, 0x2, 0x3d, 0x3e, 0x7, 0x6, 0x2, 0x2, 0x3e, 0x9, 0x3, 0x2, 
    0x2, 0x2, 0x3f, 0x40, 0x7, 0x7, 0x2, 0x2, 0x40, 0xb, 0x3, 0x2, 0x2, 
    0x2, 0x41, 0x42, 0x7, 0x8, 0x2, 0x2, 0x42, 0xd, 0x3, 0x2, 0x2, 0x2, 
    0x43, 0x44, 0x7, 0x9, 0x2, 0x2, 0x44, 0xf, 0x3, 0x2, 0x2, 0x2, 0x45, 
    0x46, 0x7, 0xa, 0x2, 0x2, 0x46, 0x11, 0x3, 0x2, 0x2, 0x2, 0x47, 0x48, 
    0x7, 0xb, 0x2, 0x2, 0x48, 0x13, 0x3, 0x2, 0x2, 0x2, 0x49, 0x4a, 0x7, 
    0xc, 0x2, 0x2, 0x4a, 0x15, 0x3, 0x2, 0x2, 0x2, 0x4b, 0x4c, 0x7, 0xd, 
    0x2, 0x2, 0x4c, 0x17, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x7, 0xe, 0x2, 
    0x2, 0x4e, 0x19, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x7, 0xf, 0x2, 0x2, 
    0x50, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x51, 0x52, 0x7, 0x10, 0x2, 0x2, 0x52, 
    0x1d, 0x3, 0x2, 0x2, 0x2, 0x53, 0x54, 0x7, 0x11, 0x2, 0x2, 0x54, 0x1f, 
    0x3, 0x2, 0x2, 0x2, 0x55, 0x56, 0x7, 0x12, 0x2, 0x2, 0x56, 0x21, 0x3, 
    0x2, 0x2, 0x2, 0x57, 0x58, 0x7, 0x16, 0x2, 0x2, 0x58, 0x23, 0x3, 0x2, 
    0x2, 0x2, 0x4, 0x27, 0x39, 
  };

  atn::ATNDeserializer deserializer;
  _atn = deserializer.deserialize(_serializedATN);

  size_t count = _atn.getNumberOfDecisions();
  _decisionToDFA.reserve(count);
  for (size_t i = 0; i < count; i++) { 
    _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);
  }
}

SV3_1aSplitterParser::Initializer SV3_1aSplitterParser::_init;