X-Git-Url: https://gitweb.ps.run/toc/blobdiff_plain/b64d16088b29615d222d33450cf0315467400e59..17fac686375c2823d22415e32e5b7e63bbfe7c54:/gen/TocParser.cpp diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp index eb6928d..c5f639d 100644 --- a/gen/TocParser.cpp +++ b/gen/TocParser.cpp @@ -2,7 +2,6 @@ // Generated from Toc.g4 by ANTLR 4.9.2 -#include "TocListener.h" #include "TocParser.h" @@ -54,17 +53,6 @@ size_t TocParser::ProgContext::getRuleIndex() const { return TocParser::RuleProg; } -void TocParser::ProgContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterProg(this); -} - -void TocParser::ProgContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitProg(this); -} TocParser::ProgContext* TocParser::prog() { ProgContext *_localctx = _tracker.createInstance(_ctx, getState()); @@ -80,20 +68,20 @@ TocParser::ProgContext* TocParser::prog() { }); try { enterOuterAlt(_localctx, 1); - setState(73); + setState(101); _errHandler->sync(this); _la = _input->LA(1); do { - setState(72); + setState(100); decl(); - setState(75); + setState(103); _errHandler->sync(this); _la = _input->LA(1); } while ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__0) - | (1ULL << TocParser::T__3) - | (1ULL << TocParser::T__9))) != 0)); - setState(77); + ((1ULL << _la) & ((1ULL << TocParser::T__1) + | (1ULL << TocParser::T__7) + | (1ULL << TocParser::T__13))) != 0)); + setState(105); match(TocParser::EOF); } @@ -129,17 +117,6 @@ size_t TocParser::DeclContext::getRuleIndex() const { return TocParser::RuleDecl; } -void TocParser::DeclContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterDecl(this); -} - -void TocParser::DeclContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitDecl(this); -} TocParser::DeclContext* TocParser::decl() { DeclContext *_localctx = _tracker.createInstance(_ctx, getState()); @@ -153,26 +130,28 @@ TocParser::DeclContext* TocParser::decl() { exitRule(); }); try { - setState(82); + setState(112); _errHandler->sync(this); switch (_input->LA(1)) { - case TocParser::T__0: { + case TocParser::T__1: { enterOuterAlt(_localctx, 1); - setState(79); + setState(107); varDecl(); + setState(108); + match(TocParser::T__0); break; } - case TocParser::T__3: { + case TocParser::T__7: { enterOuterAlt(_localctx, 2); - setState(80); + setState(110); funcDecl(); break; } - case TocParser::T__9: { + case TocParser::T__13: { enterOuterAlt(_localctx, 3); - setState(81); + setState(111); structDecl(); break; } @@ -206,17 +185,6 @@ size_t TocParser::VarDeclContext::getRuleIndex() const { return TocParser::RuleVarDecl; } -void TocParser::VarDeclContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterVarDecl(this); -} - -void TocParser::VarDeclContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitVarDecl(this); -} TocParser::VarDeclContext* TocParser::varDecl() { VarDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); @@ -231,9 +199,9 @@ TocParser::VarDeclContext* TocParser::varDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(84); - match(TocParser::T__0); - setState(85); + setState(114); + match(TocParser::T__1); + setState(115); var(); } @@ -269,17 +237,6 @@ size_t TocParser::VarContext::getRuleIndex() const { return TocParser::RuleVar; } -void TocParser::VarContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterVar(this); -} - -void TocParser::VarContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitVar(this); -} TocParser::VarContext* TocParser::var() { VarContext *_localctx = _tracker.createInstance(_ctx, getState()); @@ -295,21 +252,21 @@ TocParser::VarContext* TocParser::var() { }); try { enterOuterAlt(_localctx, 1); - setState(87); + setState(117); varName(); - setState(88); - match(TocParser::T__1); - setState(89); + setState(118); + match(TocParser::T__2); + setState(119); type(); - setState(93); + setState(123); _errHandler->sync(this); _la = _input->LA(1); - if (_la == TocParser::T__2) { - setState(91); - match(TocParser::T__2); - setState(92); + if (_la == TocParser::T__3) { + setState(121); + match(TocParser::T__3); + setState(122); expr(); } @@ -323,6 +280,66 @@ TocParser::VarContext* TocParser::var() { return _localctx; } +//----------------- VarInitContext ------------------------------------------------------------------ + +TocParser::VarInitContext::VarInitContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::VarNameContext* TocParser::VarInitContext::varName() { + return getRuleContext(0); +} + +TocParser::TypeContext* TocParser::VarInitContext::type() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::VarInitContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::VarInitContext::getRuleIndex() const { + return TocParser::RuleVarInit; +} + + +TocParser::VarInitContext* TocParser::varInit() { + VarInitContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 8, TocParser::RuleVarInit); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(125); + varName(); + + setState(126); + match(TocParser::T__2); + setState(127); + type(); + + setState(129); + match(TocParser::T__3); + setState(130); + expr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + //----------------- TypeContext ------------------------------------------------------------------ TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState) @@ -333,26 +350,24 @@ TocParser::TypeNameContext* TocParser::TypeContext::typeName() { return getRuleContext(0); } - -size_t TocParser::TypeContext::getRuleIndex() const { - return TocParser::RuleType; +std::vector TocParser::TypeContext::typeModifier() { + return getRuleContexts(); } -void TocParser::TypeContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterType(this); +TocParser::TypeModifierContext* TocParser::TypeContext::typeModifier(size_t i) { + return getRuleContext(i); } -void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitType(this); + +size_t TocParser::TypeContext::getRuleIndex() const { + return TocParser::RuleType; } + TocParser::TypeContext* TocParser::type() { TypeContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 8, TocParser::RuleType); + enterRule(_localctx, 10, TocParser::RuleType); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -363,8 +378,90 @@ TocParser::TypeContext* TocParser::type() { }); try { enterOuterAlt(_localctx, 1); - setState(95); + setState(132); typeName(); + setState(136); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__4 + + || _la == TocParser::T__5) { + setState(133); + typeModifier(); + setState(138); + _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; +} + +//----------------- TypeModifierContext ------------------------------------------------------------------ + +TocParser::TypeModifierContext::TypeModifierContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +tree::TerminalNode* TocParser::TypeModifierContext::INT_LIT() { + return getToken(TocParser::INT_LIT, 0); +} + + +size_t TocParser::TypeModifierContext::getRuleIndex() const { + return TocParser::RuleTypeModifier; +} + + +TocParser::TypeModifierContext* TocParser::typeModifier() { + TypeModifierContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 12, TocParser::RuleTypeModifier); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(145); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__4: { + enterOuterAlt(_localctx, 1); + setState(139); + match(TocParser::T__4); + break; + } + + case TocParser::T__5: { + enterOuterAlt(_localctx, 2); + setState(140); + match(TocParser::T__5); + setState(142); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::INT_LIT) { + setState(141); + match(TocParser::INT_LIT); + } + setState(144); + match(TocParser::T__6); + break; + } + + default: + throw NoViableAltException(this); + } } catch (RecognitionException &e) { @@ -391,21 +488,10 @@ size_t TocParser::FuncDeclContext::getRuleIndex() const { return TocParser::RuleFuncDecl; } -void TocParser::FuncDeclContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterFuncDecl(this); -} - -void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitFuncDecl(this); -} TocParser::FuncDeclContext* TocParser::funcDecl() { FuncDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 10, TocParser::RuleFuncDecl); + enterRule(_localctx, 14, TocParser::RuleFuncDecl); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -416,9 +502,9 @@ TocParser::FuncDeclContext* TocParser::funcDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(97); - match(TocParser::T__3); - setState(98); + setState(147); + match(TocParser::T__7); + setState(148); func(); } @@ -453,26 +539,20 @@ TocParser::TypeContext* TocParser::FuncContext::type() { return getRuleContext(0); } +TocParser::GenericDeclContext* TocParser::FuncContext::genericDecl() { + return getRuleContext(0); +} + size_t TocParser::FuncContext::getRuleIndex() const { return TocParser::RuleFunc; } -void TocParser::FuncContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterFunc(this); -} - -void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitFunc(this); -} TocParser::FuncContext* TocParser::func() { FuncContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 12, TocParser::RuleFunc); + enterRule(_localctx, 16, TocParser::RuleFunc); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -483,20 +563,28 @@ TocParser::FuncContext* TocParser::func() { }); try { enterOuterAlt(_localctx, 1); - setState(100); + setState(150); funcName(); - setState(101); - match(TocParser::T__4); - setState(102); + setState(152); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::T__14) { + setState(151); + genericDecl(); + } + setState(154); + match(TocParser::T__8); + setState(155); parameter(); - setState(103); - match(TocParser::T__5); + setState(156); + match(TocParser::T__9); - setState(104); - match(TocParser::T__1); - setState(105); + setState(157); + match(TocParser::T__2); + setState(158); type(); - setState(107); + setState(160); body(); } @@ -528,21 +616,10 @@ size_t TocParser::ParameterContext::getRuleIndex() const { return TocParser::RuleParameter; } -void TocParser::ParameterContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterParameter(this); -} - -void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitParameter(this); -} TocParser::ParameterContext* TocParser::parameter() { ParameterContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 14, TocParser::RuleParameter); + enterRule(_localctx, 18, TocParser::RuleParameter); size_t _la = 0; #if __cplusplus > 201703L @@ -554,22 +631,22 @@ TocParser::ParameterContext* TocParser::parameter() { }); try { enterOuterAlt(_localctx, 1); - setState(117); + setState(170); _errHandler->sync(this); _la = _input->LA(1); if (_la == TocParser::NAME) { - setState(109); + setState(162); var(); - setState(114); + setState(167); _errHandler->sync(this); _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(110); - match(TocParser::T__6); - setState(111); + while (_la == TocParser::T__10) { + setState(163); + match(TocParser::T__10); + setState(164); var(); - setState(116); + setState(169); _errHandler->sync(this); _la = _input->LA(1); } @@ -604,21 +681,10 @@ size_t TocParser::BodyContext::getRuleIndex() const { return TocParser::RuleBody; } -void TocParser::BodyContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterBody(this); -} - -void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitBody(this); -} TocParser::BodyContext* TocParser::body() { BodyContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 16, TocParser::RuleBody); + enterRule(_localctx, 20, TocParser::RuleBody); size_t _la = 0; #if __cplusplus > 201703L @@ -630,27 +696,40 @@ TocParser::BodyContext* TocParser::body() { }); try { enterOuterAlt(_localctx, 1); - setState(119); - match(TocParser::T__7); - setState(123); + setState(172); + match(TocParser::T__11); + setState(176); _errHandler->sync(this); _la = _input->LA(1); while ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__0) + ((1ULL << _la) & ((1ULL << TocParser::T__1) | (1ULL << TocParser::T__4) - | (1ULL << TocParser::T__10) - | (1ULL << TocParser::T__11) - | (1ULL << TocParser::T__12) - | (1ULL << TocParser::INTLIT) + | (1ULL << TocParser::T__8) + | (1ULL << TocParser::T__16) + | (1ULL << TocParser::T__18) + | (1ULL << TocParser::T__20) + | (1ULL << TocParser::T__21) + | (1ULL << TocParser::T__22) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::T__31) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) | (1ULL << TocParser::NAME))) != 0)) { - setState(120); + setState(173); stmt(); - setState(125); + setState(178); _errHandler->sync(this); _la = _input->LA(1); } - setState(126); - match(TocParser::T__8); + setState(179); + match(TocParser::T__12); } catch (RecognitionException &e) { @@ -672,6 +751,10 @@ TocParser::StructNameContext* TocParser::StructDeclContext::structName() { return getRuleContext(0); } +TocParser::GenericDeclContext* TocParser::StructDeclContext::genericDecl() { + return getRuleContext(0); +} + std::vector TocParser::StructDeclContext::structMember() { return getRuleContexts(); } @@ -685,21 +768,10 @@ size_t TocParser::StructDeclContext::getRuleIndex() const { return TocParser::RuleStructDecl; } -void TocParser::StructDeclContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStructDecl(this); -} - -void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStructDecl(this); -} TocParser::StructDeclContext* TocParser::structDecl() { StructDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 18, TocParser::RuleStructDecl); + enterRule(_localctx, 22, TocParser::RuleStructDecl); size_t _la = 0; #if __cplusplus > 201703L @@ -711,24 +783,32 @@ TocParser::StructDeclContext* TocParser::structDecl() { }); try { enterOuterAlt(_localctx, 1); - setState(128); - match(TocParser::T__9); - setState(129); + setState(181); + match(TocParser::T__13); + setState(182); structName(); - setState(130); - match(TocParser::T__7); - setState(134); + setState(184); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::T__14) { + setState(183); + genericDecl(); + } + setState(186); + match(TocParser::T__11); + setState(190); _errHandler->sync(this); _la = _input->LA(1); while (_la == TocParser::NAME) { - setState(131); + setState(187); structMember(); - setState(136); + setState(192); _errHandler->sync(this); _la = _input->LA(1); } - setState(137); - match(TocParser::T__8); + setState(193); + match(TocParser::T__12); } catch (RecognitionException &e) { @@ -759,21 +839,10 @@ size_t TocParser::StructMemberContext::getRuleIndex() const { return TocParser::RuleStructMember; } -void TocParser::StructMemberContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStructMember(this); -} - -void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStructMember(this); -} TocParser::StructMemberContext* TocParser::structMember() { StructMemberContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 20, TocParser::RuleStructMember); + enterRule(_localctx, 24, TocParser::RuleStructMember); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -783,19 +852,19 @@ TocParser::StructMemberContext* TocParser::structMember() { exitRule(); }); try { - setState(141); + setState(197); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 7, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 12, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(139); + setState(195); structVar(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(140); + setState(196); structMethod(); break; } @@ -829,21 +898,10 @@ size_t TocParser::StructVarContext::getRuleIndex() const { return TocParser::RuleStructVar; } -void TocParser::StructVarContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStructVar(this); -} - -void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStructVar(this); -} TocParser::StructVarContext* TocParser::structVar() { StructVarContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 22, TocParser::RuleStructVar); + enterRule(_localctx, 26, TocParser::RuleStructVar); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -854,8 +912,10 @@ TocParser::StructVarContext* TocParser::structVar() { }); try { enterOuterAlt(_localctx, 1); - setState(143); + setState(199); var(); + setState(200); + match(TocParser::T__0); } catch (RecognitionException &e) { @@ -882,21 +942,10 @@ size_t TocParser::StructMethodContext::getRuleIndex() const { return TocParser::RuleStructMethod; } -void TocParser::StructMethodContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStructMethod(this); -} - -void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStructMethod(this); -} TocParser::StructMethodContext* TocParser::structMethod() { StructMethodContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 24, TocParser::RuleStructMethod); + enterRule(_localctx, 28, TocParser::RuleStructMethod); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -907,7 +956,7 @@ TocParser::StructMethodContext* TocParser::structMethod() { }); try { enterOuterAlt(_localctx, 1); - setState(145); + setState(202); func(); } @@ -920,56 +969,30 @@ TocParser::StructMethodContext* TocParser::structMethod() { return _localctx; } -//----------------- StmtContext ------------------------------------------------------------------ +//----------------- GenericDeclContext ------------------------------------------------------------------ -TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState) +TocParser::GenericDeclContext::GenericDeclContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::VarDeclContext* TocParser::StmtContext::varDecl() { - return getRuleContext(0); -} - -TocParser::ConditionalContext* TocParser::StmtContext::conditional() { - return getRuleContext(0); -} - -TocParser::LoopContext* TocParser::StmtContext::loop() { - return getRuleContext(0); -} - -TocParser::AssignmentContext* TocParser::StmtContext::assignment() { - return getRuleContext(0); -} - -TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() { - return getRuleContext(0); +std::vector TocParser::GenericDeclContext::typeName() { + return getRuleContexts(); } -TocParser::ExprContext* TocParser::StmtContext::expr() { - return getRuleContext(0); +TocParser::TypeNameContext* TocParser::GenericDeclContext::typeName(size_t i) { + return getRuleContext(i); } -size_t TocParser::StmtContext::getRuleIndex() const { - return TocParser::RuleStmt; -} - -void TocParser::StmtContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStmt(this); +size_t TocParser::GenericDeclContext::getRuleIndex() const { + return TocParser::RuleGenericDecl; } -void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStmt(this); -} -TocParser::StmtContext* TocParser::stmt() { - StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 26, TocParser::RuleStmt); +TocParser::GenericDeclContext* TocParser::genericDecl() { + GenericDeclContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 30, TocParser::RuleGenericDecl); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -980,42 +1003,155 @@ TocParser::StmtContext* TocParser::stmt() { }); try { enterOuterAlt(_localctx, 1); - setState(153); + setState(204); + match(TocParser::T__14); + setState(205); + typeName(); + setState(210); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 8, _ctx)) { - case 1: { - setState(147); - varDecl(); - break; - } - - case 2: { - setState(148); - conditional(); - break; + _la = _input->LA(1); + while (_la == TocParser::T__10) { + setState(206); + match(TocParser::T__10); + setState(207); + typeName(); + setState(212); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(213); + match(TocParser::T__15); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- StmtContext ------------------------------------------------------------------ + +TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::VarDeclContext* TocParser::StmtContext::varDecl() { + return getRuleContext(0); +} + +TocParser::IfStmtContext* TocParser::StmtContext::ifStmt() { + return getRuleContext(0); +} + +TocParser::SwitchStmtContext* TocParser::StmtContext::switchStmt() { + return getRuleContext(0); +} + +TocParser::ForStmtContext* TocParser::StmtContext::forStmt() { + return getRuleContext(0); +} + +TocParser::WhileStmtContext* TocParser::StmtContext::whileStmt() { + return getRuleContext(0); +} + +TocParser::AssignStmtContext* TocParser::StmtContext::assignStmt() { + return getRuleContext(0); +} + +TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() { + return getRuleContext(0); +} + +TocParser::ExprContext* TocParser::StmtContext::expr() { + return getRuleContext(0); +} + + +size_t TocParser::StmtContext::getRuleIndex() const { + return TocParser::RuleStmt; +} + + +TocParser::StmtContext* TocParser::stmt() { + StmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 32, TocParser::RuleStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(231); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 14, _ctx)) { + case 1: { + enterOuterAlt(_localctx, 1); + setState(215); + varDecl(); + setState(216); + match(TocParser::T__0); + break; + } + + case 2: { + enterOuterAlt(_localctx, 2); + setState(218); + ifStmt(); + break; } case 3: { - setState(149); - loop(); + enterOuterAlt(_localctx, 3); + setState(219); + switchStmt(); break; } case 4: { - setState(150); - assignment(); + enterOuterAlt(_localctx, 4); + setState(220); + forStmt(); break; } case 5: { - setState(151); - returnStmt(); + enterOuterAlt(_localctx, 5); + setState(221); + whileStmt(); break; } case 6: { - setState(152); + enterOuterAlt(_localctx, 6); + setState(222); + assignStmt(); + setState(223); + match(TocParser::T__0); + break; + } + + case 7: { + enterOuterAlt(_localctx, 7); + setState(225); + returnStmt(); + setState(226); + match(TocParser::T__0); + break; + } + + case 8: { + enterOuterAlt(_localctx, 8); + setState(228); expr(); + setState(229); + match(TocParser::T__0); break; } @@ -1033,36 +1169,42 @@ TocParser::StmtContext* TocParser::stmt() { return _localctx; } -//----------------- ConditionalContext ------------------------------------------------------------------ +//----------------- IfStmtContext ------------------------------------------------------------------ -TocParser::ConditionalContext::ConditionalContext(ParserRuleContext *parent, size_t invokingState) +TocParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::IfCondContext* TocParser::ConditionalContext::ifCond() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::IfStmtContext::expr() { + return getRuleContext(0); } +TocParser::BodyContext* TocParser::IfStmtContext::body() { + return getRuleContext(0); +} + +std::vector TocParser::IfStmtContext::elseIfStmt() { + return getRuleContexts(); +} -size_t TocParser::ConditionalContext::getRuleIndex() const { - return TocParser::RuleConditional; +TocParser::ElseIfStmtContext* TocParser::IfStmtContext::elseIfStmt(size_t i) { + return getRuleContext(i); } -void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterConditional(this); +TocParser::ElseStmtContext* TocParser::IfStmtContext::elseStmt() { + return getRuleContext(0); } -void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitConditional(this); + +size_t TocParser::IfStmtContext::getRuleIndex() const { + return TocParser::RuleIfStmt; } -TocParser::ConditionalContext* TocParser::conditional() { - ConditionalContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 28, TocParser::RuleConditional); + +TocParser::IfStmtContext* TocParser::ifStmt() { + IfStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 34, TocParser::RuleIfStmt); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1072,9 +1214,34 @@ TocParser::ConditionalContext* TocParser::conditional() { exitRule(); }); try { + size_t alt; enterOuterAlt(_localctx, 1); - setState(155); - ifCond(); + setState(233); + match(TocParser::T__16); + setState(234); + expr(); + setState(235); + body(); + setState(239); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 15, _ctx); + while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) { + if (alt == 1) { + setState(236); + elseIfStmt(); + } + setState(241); + _errHandler->sync(this); + alt = getInterpreter()->adaptivePredict(_input, 15, _ctx); + } + setState(243); + _errHandler->sync(this); + + _la = _input->LA(1); + if (_la == TocParser::T__17) { + setState(242); + elseStmt(); + } } catch (RecognitionException &e) { @@ -1086,40 +1253,77 @@ TocParser::ConditionalContext* TocParser::conditional() { return _localctx; } -//----------------- IfCondContext ------------------------------------------------------------------ +//----------------- ElseIfStmtContext ------------------------------------------------------------------ -TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ElseIfStmtContext::ElseIfStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::IfCondContext::expr() { +TocParser::ExprContext* TocParser::ElseIfStmtContext::expr() { return getRuleContext(0); } -TocParser::BodyContext* TocParser::IfCondContext::body() { +TocParser::BodyContext* TocParser::ElseIfStmtContext::body() { return getRuleContext(0); } -size_t TocParser::IfCondContext::getRuleIndex() const { - return TocParser::RuleIfCond; +size_t TocParser::ElseIfStmtContext::getRuleIndex() const { + return TocParser::RuleElseIfStmt; +} + + +TocParser::ElseIfStmtContext* TocParser::elseIfStmt() { + ElseIfStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 36, TocParser::RuleElseIfStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(245); + match(TocParser::T__17); + setState(246); + match(TocParser::T__16); + setState(247); + expr(); + setState(248); + body(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- ElseStmtContext ------------------------------------------------------------------ + +TocParser::ElseStmtContext::ElseStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { } -void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterIfCond(this); +TocParser::BodyContext* TocParser::ElseStmtContext::body() { + return getRuleContext(0); } -void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitIfCond(this); + +size_t TocParser::ElseStmtContext::getRuleIndex() const { + return TocParser::RuleElseStmt; } -TocParser::IfCondContext* TocParser::ifCond() { - IfCondContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 30, TocParser::RuleIfCond); + +TocParser::ElseStmtContext* TocParser::elseStmt() { + ElseStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 38, TocParser::RuleElseStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1130,11 +1334,168 @@ TocParser::IfCondContext* TocParser::ifCond() { }); try { enterOuterAlt(_localctx, 1); - setState(157); - match(TocParser::T__10); - setState(158); + setState(250); + match(TocParser::T__17); + setState(251); + body(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SwitchStmtContext ------------------------------------------------------------------ + +TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() { + return getRuleContext(0); +} + +TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() { + return getRuleContext(0); +} + + +size_t TocParser::SwitchStmtContext::getRuleIndex() const { + return TocParser::RuleSwitchStmt; +} + + +TocParser::SwitchStmtContext* TocParser::switchStmt() { + SwitchStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 40, TocParser::RuleSwitchStmt); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(253); + match(TocParser::T__18); + setState(254); + identifierExpr(); + setState(255); + switchBody(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SwitchBodyContext ------------------------------------------------------------------ + +TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TocParser::SwitchBodyContext::switchCase() { + return getRuleContexts(); +} + +TocParser::SwitchCaseContext* TocParser::SwitchBodyContext::switchCase(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::SwitchBodyContext::getRuleIndex() const { + return TocParser::RuleSwitchBody; +} + + +TocParser::SwitchBodyContext* TocParser::switchBody() { + SwitchBodyContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 42, TocParser::RuleSwitchBody); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(257); + match(TocParser::T__11); + setState(261); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__19) { + setState(258); + switchCase(); + setState(263); + _errHandler->sync(this); + _la = _input->LA(1); + } + setState(264); + match(TocParser::T__12); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- SwitchCaseContext ------------------------------------------------------------------ + +TocParser::SwitchCaseContext::SwitchCaseContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::ExprContext* TocParser::SwitchCaseContext::expr() { + return getRuleContext(0); +} + +TocParser::BodyContext* TocParser::SwitchCaseContext::body() { + return getRuleContext(0); +} + + +size_t TocParser::SwitchCaseContext::getRuleIndex() const { + return TocParser::RuleSwitchCase; +} + + +TocParser::SwitchCaseContext* TocParser::switchCase() { + SwitchCaseContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 44, TocParser::RuleSwitchCase); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(266); + match(TocParser::T__19); + setState(267); expr(); - setState(159); + setState(268); body(); } @@ -1147,36 +1508,41 @@ TocParser::IfCondContext* TocParser::ifCond() { return _localctx; } -//----------------- LoopContext ------------------------------------------------------------------ +//----------------- ForStmtContext ------------------------------------------------------------------ -TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() { - return getRuleContext(0); +std::vector TocParser::ForStmtContext::expr() { + return getRuleContexts(); +} + +TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) { + return getRuleContext(i); } +TocParser::BodyContext* TocParser::ForStmtContext::body() { + return getRuleContext(0); +} -size_t TocParser::LoopContext::getRuleIndex() const { - return TocParser::RuleLoop; +TocParser::VarInitContext* TocParser::ForStmtContext::varInit() { + return getRuleContext(0); } -void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterLoop(this); +TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() { + return getRuleContext(0); } -void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLoop(this); + +size_t TocParser::ForStmtContext::getRuleIndex() const { + return TocParser::RuleForStmt; } -TocParser::LoopContext* TocParser::loop() { - LoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 32, TocParser::RuleLoop); + +TocParser::ForStmtContext* TocParser::forStmt() { + ForStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 46, TocParser::RuleForStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1187,8 +1553,36 @@ TocParser::LoopContext* TocParser::loop() { }); try { enterOuterAlt(_localctx, 1); - setState(161); - whileLoop(); + setState(270); + match(TocParser::T__20); + setState(273); + _errHandler->sync(this); + switch (getInterpreter()->adaptivePredict(_input, 18, _ctx)) { + case 1: { + setState(271); + varInit(); + break; + } + + case 2: { + setState(272); + assignStmt(); + break; + } + + default: + break; + } + setState(275); + match(TocParser::T__10); + setState(276); + expr(); + setState(277); + match(TocParser::T__10); + setState(278); + expr(); + setState(279); + body(); } catch (RecognitionException &e) { @@ -1200,40 +1594,29 @@ TocParser::LoopContext* TocParser::loop() { return _localctx; } -//----------------- WhileLoopContext ------------------------------------------------------------------ +//----------------- WhileStmtContext ------------------------------------------------------------------ -TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState) +TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::ExprContext* TocParser::WhileLoopContext::expr() { +TocParser::ExprContext* TocParser::WhileStmtContext::expr() { return getRuleContext(0); } -TocParser::BodyContext* TocParser::WhileLoopContext::body() { +TocParser::BodyContext* TocParser::WhileStmtContext::body() { return getRuleContext(0); } -size_t TocParser::WhileLoopContext::getRuleIndex() const { - return TocParser::RuleWhileLoop; -} - -void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterWhileLoop(this); +size_t TocParser::WhileStmtContext::getRuleIndex() const { + return TocParser::RuleWhileStmt; } -void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitWhileLoop(this); -} -TocParser::WhileLoopContext* TocParser::whileLoop() { - WhileLoopContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 34, TocParser::RuleWhileLoop); +TocParser::WhileStmtContext* TocParser::whileStmt() { + WhileStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 48, TocParser::RuleWhileStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1244,11 +1627,11 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { }); try { enterOuterAlt(_localctx, 1); - setState(163); - match(TocParser::T__11); - setState(164); + setState(281); + match(TocParser::T__21); + setState(282); expr(); - setState(165); + setState(283); body(); } @@ -1261,40 +1644,29 @@ TocParser::WhileLoopContext* TocParser::whileLoop() { return _localctx; } -//----------------- AssignmentContext ------------------------------------------------------------------ +//----------------- AssignStmtContext ------------------------------------------------------------------ -TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() { + return getRuleContext(0); } -TocParser::ExprContext* TocParser::AssignmentContext::expr() { +TocParser::ExprContext* TocParser::AssignStmtContext::expr() { return getRuleContext(0); } -size_t TocParser::AssignmentContext::getRuleIndex() const { - return TocParser::RuleAssignment; -} - -void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterAssignment(this); +size_t TocParser::AssignStmtContext::getRuleIndex() const { + return TocParser::RuleAssignStmt; } -void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitAssignment(this); -} -TocParser::AssignmentContext* TocParser::assignment() { - AssignmentContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 36, TocParser::RuleAssignment); +TocParser::AssignStmtContext* TocParser::assignStmt() { + AssignStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 50, TocParser::RuleAssignStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1305,11 +1677,11 @@ TocParser::AssignmentContext* TocParser::assignment() { }); try { enterOuterAlt(_localctx, 1); - setState(167); - identifier(); - setState(168); - match(TocParser::T__2); - setState(169); + setState(285); + identifierExpr(); + setState(286); + match(TocParser::T__3); + setState(287); expr(); } @@ -1337,21 +1709,10 @@ size_t TocParser::ReturnStmtContext::getRuleIndex() const { return TocParser::RuleReturnStmt; } -void TocParser::ReturnStmtContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterReturnStmt(this); -} - -void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitReturnStmt(this); -} TocParser::ReturnStmtContext* TocParser::returnStmt() { ReturnStmtContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 38, TocParser::RuleReturnStmt); + enterRule(_localctx, 52, TocParser::RuleReturnStmt); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1362,9 +1723,9 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() { }); try { enterOuterAlt(_localctx, 1); - setState(171); - match(TocParser::T__12); - setState(172); + setState(289); + match(TocParser::T__22); + setState(290); expr(); } @@ -1383,32 +1744,28 @@ TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingSt : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::ExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::ExprContext::literal() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::ExprContext::identifier() { - return getRuleContext(0); +TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::SubscriptContext* TocParser::ExprContext::subscript() { - return getRuleContext(0); +TocParser::LitExprContext* TocParser::ExprContext::litExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() { + return getRuleContext(0); } TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() { return getRuleContext(0); } -TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() { - return getRuleContext(0); +TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() { + return getRuleContext(0); +} + +TocParser::OpExprContext* TocParser::ExprContext::opExpr() { + return getRuleContext(0); } @@ -1416,21 +1773,10 @@ size_t TocParser::ExprContext::getRuleIndex() const { return TocParser::RuleExpr; } -void TocParser::ExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterExpr(this); -} - -void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitExpr(this); -} TocParser::ExprContext* TocParser::expr() { ExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 40, TocParser::RuleExpr); + enterRule(_localctx, 54, TocParser::RuleExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1440,55 +1786,48 @@ TocParser::ExprContext* TocParser::expr() { exitRule(); }); try { - setState(181); + setState(298); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 9, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 19, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(174); - funcCall(); + setState(292); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(175); - literal(); + setState(293); + litExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(176); - identifier(); + setState(294); + identifierExpr(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(177); - subscript(); + setState(295); + parenExpr(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(178); - memberAccess(); + setState(296); + accessExpr(); break; } case 6: { enterOuterAlt(_localctx, 6); - setState(179); - parenExpr(); - break; - } - - case 7: { - enterOuterAlt(_localctx, 7); - setState(180); - operatorExpr(); + setState(297); + opExpr(); break; } @@ -1512,50 +1851,35 @@ TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonOpExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::NonOpExprContext::literal() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() { - return getRuleContext(0); +TocParser::FuncExprContext* TocParser::NonOpExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() { - return getRuleContext(0); +TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::NonOpExprContext::identifierExpr() { + return getRuleContext(0); } TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() { return getRuleContext(0); } +TocParser::AccessExprContext* TocParser::NonOpExprContext::accessExpr() { + return getRuleContext(0); +} + size_t TocParser::NonOpExprContext::getRuleIndex() const { return TocParser::RuleNonOpExpr; } -void TocParser::NonOpExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNonOpExpr(this); -} - -void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNonOpExpr(this); -} TocParser::NonOpExprContext* TocParser::nonOpExpr() { NonOpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 42, TocParser::RuleNonOpExpr); + enterRule(_localctx, 56, TocParser::RuleNonOpExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1565,48 +1889,41 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { exitRule(); }); try { - setState(189); + setState(305); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 10, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 20, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(183); - funcCall(); + setState(300); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(184); - literal(); + setState(301); + litExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(185); - identifier(); + setState(302); + identifierExpr(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(186); - subscript(); + setState(303); + parenExpr(); break; } case 5: { enterOuterAlt(_localctx, 5); - setState(187); - memberAccess(); - break; - } - - case 6: { - enterOuterAlt(_localctx, 6); - setState(188); - parenExpr(); + setState(304); + accessExpr(); break; } @@ -1624,52 +1941,33 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() { return _localctx; } -//----------------- NonSubscriptExprContext ------------------------------------------------------------------ +//----------------- NonAccessExprContext ------------------------------------------------------------------ -TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() { - return getRuleContext(0); -} - -TocParser::LiteralContext* TocParser::NonSubscriptExprContext::literal() { - return getRuleContext(0); -} - -TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() { - return getRuleContext(0); +TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() { + return getRuleContext(0); } -TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() { + return getRuleContext(0); } -TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() { +TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() { return getRuleContext(0); } -size_t TocParser::NonSubscriptExprContext::getRuleIndex() const { - return TocParser::RuleNonSubscriptExpr; -} - -void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNonSubscriptExpr(this); +size_t TocParser::NonAccessExprContext::getRuleIndex() const { + return TocParser::RuleNonAccessExpr; } -void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNonSubscriptExpr(this); -} -TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { - NonSubscriptExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 44, TocParser::RuleNonSubscriptExpr); +TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { + NonAccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 58, TocParser::RuleNonAccessExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1679,40 +1977,26 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { exitRule(); }); try { - setState(196); + setState(310); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 11, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 21, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(191); - funcCall(); + setState(307); + funcExpr(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(192); - literal(); + setState(308); + identifierExpr(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(193); - identifier(); - break; - } - - case 4: { - enterOuterAlt(_localctx, 4); - setState(194); - memberAccess(); - break; - } - - case 5: { - enterOuterAlt(_localctx, 5); - setState(195); + setState(309); parenExpr(); break; } @@ -1731,56 +2015,126 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() { return _localctx; } -//----------------- NonAccessExprContext ------------------------------------------------------------------ +//----------------- FuncExprContext ------------------------------------------------------------------ -TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncCallContext* TocParser::NonAccessExprContext::funcCall() { - return getRuleContext(0); +TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() { + return getRuleContext(0); } -TocParser::LiteralContext* TocParser::NonAccessExprContext::literal() { - return getRuleContext(0); +std::vector TocParser::FuncExprContext::expr() { + return getRuleContexts(); } -TocParser::IdentifierContext* TocParser::NonAccessExprContext::identifier() { - return getRuleContext(0); +TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) { + return getRuleContext(i); } -TocParser::SubscriptContext* TocParser::NonAccessExprContext::subscript() { - return getRuleContext(0); + +size_t TocParser::FuncExprContext::getRuleIndex() const { + return TocParser::RuleFuncExpr; } -TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() { - return getRuleContext(0); + +TocParser::FuncExprContext* TocParser::funcExpr() { + FuncExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 60, TocParser::RuleFuncExpr); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(312); + funcName(); + setState(313); + match(TocParser::T__8); + setState(322); + _errHandler->sync(this); + + _la = _input->LA(1); + if ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__8) + | (1ULL << TocParser::T__26) + | (1ULL << TocParser::T__27) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__30) + | (1ULL << TocParser::T__31) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT) + | (1ULL << TocParser::NAME))) != 0)) { + setState(314); + expr(); + setState(319); + _errHandler->sync(this); + _la = _input->LA(1); + while (_la == TocParser::T__10) { + setState(315); + match(TocParser::T__10); + setState(316); + expr(); + setState(321); + _errHandler->sync(this); + _la = _input->LA(1); + } + } + setState(324); + match(TocParser::T__9); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; } -TocParser::OperatorExprContext* TocParser::NonAccessExprContext::operatorExpr() { - return getRuleContext(0); +//----------------- OpExprContext ------------------------------------------------------------------ + +TocParser::OpExprContext::OpExprContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { } +TocParser::BinaryOpContext* TocParser::OpExprContext::binaryOp() { + return getRuleContext(0); +} -size_t TocParser::NonAccessExprContext::getRuleIndex() const { - return TocParser::RuleNonAccessExpr; +TocParser::PrefixOpContext* TocParser::OpExprContext::prefixOp() { + return getRuleContext(0); } -void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterNonAccessExpr(this); +TocParser::PostfixOpContext* TocParser::OpExprContext::postfixOp() { + return getRuleContext(0); } -void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitNonAccessExpr(this); +TocParser::TernaryOpContext* TocParser::OpExprContext::ternaryOp() { + return getRuleContext(0); } -TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { - NonAccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 46, TocParser::RuleNonAccessExpr); + +size_t TocParser::OpExprContext::getRuleIndex() const { + return TocParser::RuleOpExpr; +} + + +TocParser::OpExprContext* TocParser::opExpr() { + OpExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 62, TocParser::RuleOpExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1790,53 +2144,138 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { exitRule(); }); try { - setState(204); + setState(330); _errHandler->sync(this); - switch (getInterpreter()->adaptivePredict(_input, 12, _ctx)) { + switch (getInterpreter()->adaptivePredict(_input, 24, _ctx)) { case 1: { enterOuterAlt(_localctx, 1); - setState(198); - funcCall(); + setState(326); + binaryOp(); break; } case 2: { enterOuterAlt(_localctx, 2); - setState(199); - literal(); + setState(327); + prefixOp(); break; } case 3: { enterOuterAlt(_localctx, 3); - setState(200); - identifier(); + setState(328); + postfixOp(); break; } case 4: { enterOuterAlt(_localctx, 4); - setState(201); - subscript(); + setState(329); + ternaryOp(); break; } - case 5: { - enterOuterAlt(_localctx, 5); - setState(202); - parenExpr(); + default: break; } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } - case 6: { - enterOuterAlt(_localctx, 6); - setState(203); - operatorExpr(); - break; - } + return _localctx; +} - default: - break; +//----------------- BinaryOpContext ------------------------------------------------------------------ + +TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +std::vector TocParser::BinaryOpContext::nonOpExpr() { + return getRuleContexts(); +} + +TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) { + return getRuleContext(i); +} + +std::vector TocParser::BinaryOpContext::binary_op() { + return getRuleContexts(); +} + +TocParser::Binary_opContext* TocParser::BinaryOpContext::binary_op(size_t i) { + return getRuleContext(i); +} + + +size_t TocParser::BinaryOpContext::getRuleIndex() const { + return TocParser::RuleBinaryOp; +} + + +TocParser::BinaryOpContext* TocParser::binaryOp() { + BinaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 64, TocParser::RuleBinaryOp); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(332); + nonOpExpr(); + setState(333); + binary_op(); + setState(334); + nonOpExpr(); + setState(340); + _errHandler->sync(this); + _la = _input->LA(1); + while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__14) + | (1ULL << TocParser::T__15) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::T__33) + | (1ULL << TocParser::T__34) + | (1ULL << TocParser::T__35) + | (1ULL << TocParser::T__36) + | (1ULL << TocParser::T__37) + | (1ULL << TocParser::T__38) + | (1ULL << TocParser::T__39) + | (1ULL << TocParser::T__40) + | (1ULL << TocParser::T__41) + | (1ULL << TocParser::T__42) + | (1ULL << TocParser::T__43) + | (1ULL << TocParser::T__44) + | (1ULL << TocParser::T__45) + | (1ULL << TocParser::T__46) + | (1ULL << TocParser::T__47) + | (1ULL << TocParser::T__48) + | (1ULL << TocParser::T__49) + | (1ULL << TocParser::T__50) + | (1ULL << TocParser::T__51) + | (1ULL << TocParser::T__52) + | (1ULL << TocParser::T__53) + | (1ULL << TocParser::T__54))) != 0)) { + setState(335); + binary_op(); + setState(336); + nonOpExpr(); + setState(342); + _errHandler->sync(this); + _la = _input->LA(1); } } @@ -1849,45 +2288,129 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() { return _localctx; } -//----------------- FuncCallContext ------------------------------------------------------------------ +//----------------- PrefixOpContext ------------------------------------------------------------------ + +TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::Prefix_opContext* TocParser::PrefixOpContext::prefix_op() { + return getRuleContext(0); +} + +TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() { + return getRuleContext(0); +} + + +size_t TocParser::PrefixOpContext::getRuleIndex() const { + return TocParser::RulePrefixOp; +} + + +TocParser::PrefixOpContext* TocParser::prefixOp() { + PrefixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 66, TocParser::RulePrefixOp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(343); + prefix_op(); + setState(344); + nonOpExpr(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- PostfixOpContext ------------------------------------------------------------------ + +TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() { + return getRuleContext(0); +} + +TocParser::Postfix_opContext* TocParser::PostfixOpContext::postfix_op() { + return getRuleContext(0); +} + + +size_t TocParser::PostfixOpContext::getRuleIndex() const { + return TocParser::RulePostfixOp; +} + + +TocParser::PostfixOpContext* TocParser::postfixOp() { + PostfixOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 68, TocParser::RulePostfixOp); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(346); + nonOpExpr(); + setState(347); + postfix_op(); + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- TernaryOpContext ------------------------------------------------------------------ -TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState) +TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() { - return getRuleContext(0); +TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() { + return getRuleContext(0); } -std::vector TocParser::FuncCallContext::expr() { +std::vector TocParser::TernaryOpContext::expr() { return getRuleContexts(); } -TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) { +TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) { return getRuleContext(i); } -size_t TocParser::FuncCallContext::getRuleIndex() const { - return TocParser::RuleFuncCall; -} - -void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterFuncCall(this); +size_t TocParser::TernaryOpContext::getRuleIndex() const { + return TocParser::RuleTernaryOp; } -void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitFuncCall(this); -} -TocParser::FuncCallContext* TocParser::funcCall() { - FuncCallContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 48, TocParser::RuleFuncCall); - size_t _la = 0; +TocParser::TernaryOpContext* TocParser::ternaryOp() { + TernaryOpContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 70, TocParser::RuleTernaryOp); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1898,35 +2421,16 @@ TocParser::FuncCallContext* TocParser::funcCall() { }); try { enterOuterAlt(_localctx, 1); - setState(206); - funcName(); - setState(207); - match(TocParser::T__4); - setState(216); - _errHandler->sync(this); - - _la = _input->LA(1); - if ((((_la & ~ 0x3fULL) == 0) && - ((1ULL << _la) & ((1ULL << TocParser::T__4) - | (1ULL << TocParser::INTLIT) - | (1ULL << TocParser::NAME))) != 0)) { - setState(208); - expr(); - setState(213); - _errHandler->sync(this); - _la = _input->LA(1); - while (_la == TocParser::T__6) { - setState(209); - match(TocParser::T__6); - setState(210); - expr(); - setState(215); - _errHandler->sync(this); - _la = _input->LA(1); - } - } - setState(218); - match(TocParser::T__5); + setState(349); + nonOpExpr(); + setState(350); + match(TocParser::T__23); + setState(351); + expr(); + setState(352); + match(TocParser::T__2); + setState(353); + expr(); } catch (RecognitionException &e) { @@ -1938,36 +2442,25 @@ TocParser::FuncCallContext* TocParser::funcCall() { return _localctx; } -//----------------- OperatorExprContext ------------------------------------------------------------------ +//----------------- IdentifierExprContext ------------------------------------------------------------------ -TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState) +TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() { - return getRuleContext(0); +TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() { + return getRuleContext(0); } -size_t TocParser::OperatorExprContext::getRuleIndex() const { - return TocParser::RuleOperatorExpr; +size_t TocParser::IdentifierExprContext::getRuleIndex() const { + return TocParser::RuleIdentifierExpr; } -void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterOperatorExpr(this); -} - -void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitOperatorExpr(this); -} -TocParser::OperatorExprContext* TocParser::operatorExpr() { - OperatorExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 50, TocParser::RuleOperatorExpr); +TocParser::IdentifierExprContext* TocParser::identifierExpr() { + IdentifierExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 72, TocParser::RuleIdentifierExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -1978,8 +2471,8 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(220); - binaryOperator(); + setState(355); + varName(); } catch (RecognitionException &e) { @@ -1991,48 +2484,37 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() { return _localctx; } -//----------------- BinaryOperatorContext ------------------------------------------------------------------ +//----------------- LitExprContext ------------------------------------------------------------------ -TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState) +TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::BinaryOperatorContext::nonOpExpr() { - return getRuleContexts(); +tree::TerminalNode* TocParser::LitExprContext::INT_LIT() { + return getToken(TocParser::INT_LIT, 0); } -TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) { - return getRuleContext(i); +tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() { + return getToken(TocParser::DECIMAL_LIT, 0); } -std::vector TocParser::BinaryOperatorContext::BINARY_OPERATOR() { - return getTokens(TocParser::BINARY_OPERATOR); +tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() { + return getToken(TocParser::STRING_LIT, 0); } -tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) { - return getToken(TocParser::BINARY_OPERATOR, i); +tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() { + return getToken(TocParser::BOOL_LIT, 0); } -size_t TocParser::BinaryOperatorContext::getRuleIndex() const { - return TocParser::RuleBinaryOperator; -} - -void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterBinaryOperator(this); +size_t TocParser::LitExprContext::getRuleIndex() const { + return TocParser::RuleLitExpr; } -void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitBinaryOperator(this); -} -TocParser::BinaryOperatorContext* TocParser::binaryOperator() { - BinaryOperatorContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 52, TocParser::RuleBinaryOperator); +TocParser::LitExprContext* TocParser::litExpr() { + LitExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 74, TocParser::RuleLitExpr); size_t _la = 0; #if __cplusplus > 201703L @@ -2044,23 +2526,18 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { }); try { enterOuterAlt(_localctx, 1); - setState(222); - nonOpExpr(); - setState(223); - match(TocParser::BINARY_OPERATOR); - setState(224); - nonOpExpr(); - setState(229); - _errHandler->sync(this); + setState(357); _la = _input->LA(1); - while (_la == TocParser::BINARY_OPERATOR) { - setState(225); - match(TocParser::BINARY_OPERATOR); - setState(226); - nonOpExpr(); - setState(231); - _errHandler->sync(this); - _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::INT_LIT) + | (1ULL << TocParser::DECIMAL_LIT) + | (1ULL << TocParser::STRING_LIT) + | (1ULL << TocParser::BOOL_LIT))) != 0))) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); } } @@ -2073,36 +2550,34 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() { return _localctx; } -//----------------- IdentifierContext ------------------------------------------------------------------ +//----------------- AccessExprContext ------------------------------------------------------------------ -TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::VarNameContext* TocParser::IdentifierContext::varName() { - return getRuleContext(0); +TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() { + return getRuleContext(0); } - -size_t TocParser::IdentifierContext::getRuleIndex() const { - return TocParser::RuleIdentifier; +std::vector TocParser::AccessExprContext::accessSubExpr() { + return getRuleContexts(); } -void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterIdentifier(this); +TocParser::AccessSubExprContext* TocParser::AccessExprContext::accessSubExpr(size_t i) { + return getRuleContext(i); } -void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitIdentifier(this); + +size_t TocParser::AccessExprContext::getRuleIndex() const { + return TocParser::RuleAccessExpr; } -TocParser::IdentifierContext* TocParser::identifier() { - IdentifierContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 54, TocParser::RuleIdentifier); + +TocParser::AccessExprContext* TocParser::accessExpr() { + AccessExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 76, TocParser::RuleAccessExpr); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2113,8 +2588,21 @@ TocParser::IdentifierContext* TocParser::identifier() { }); try { enterOuterAlt(_localctx, 1); - setState(232); - varName(); + setState(359); + nonAccessExpr(); + setState(361); + _errHandler->sync(this); + _la = _input->LA(1); + do { + setState(360); + accessSubExpr(); + setState(363); + _errHandler->sync(this); + _la = _input->LA(1); + } while ((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__5) + | (1ULL << TocParser::T__24) + | (1ULL << TocParser::T__25))) != 0)); } catch (RecognitionException &e) { @@ -2126,36 +2614,29 @@ TocParser::IdentifierContext* TocParser::identifier() { return _localctx; } -//----------------- LiteralContext ------------------------------------------------------------------ +//----------------- AccessSubExprContext ------------------------------------------------------------------ -TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessSubExprContext::AccessSubExprContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -tree::TerminalNode* TocParser::LiteralContext::INTLIT() { - return getToken(TocParser::INTLIT, 0); +TocParser::AccessMemberContext* TocParser::AccessSubExprContext::accessMember() { + return getRuleContext(0); } - -size_t TocParser::LiteralContext::getRuleIndex() const { - return TocParser::RuleLiteral; +TocParser::AccessBracketsContext* TocParser::AccessSubExprContext::accessBrackets() { + return getRuleContext(0); } -void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterLiteral(this); -} -void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitLiteral(this); +size_t TocParser::AccessSubExprContext::getRuleIndex() const { + return TocParser::RuleAccessSubExpr; } -TocParser::LiteralContext* TocParser::literal() { - LiteralContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 56, TocParser::RuleLiteral); + +TocParser::AccessSubExprContext* TocParser::accessSubExpr() { + AccessSubExprContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 78, TocParser::RuleAccessSubExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2165,9 +2646,27 @@ TocParser::LiteralContext* TocParser::literal() { exitRule(); }); try { - enterOuterAlt(_localctx, 1); - setState(234); - match(TocParser::INTLIT); + setState(367); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__24: + case TocParser::T__25: { + enterOuterAlt(_localctx, 1); + setState(365); + accessMember(); + break; + } + + case TocParser::T__5: { + enterOuterAlt(_localctx, 2); + setState(366); + accessBrackets(); + break; + } + + default: + throw NoViableAltException(this); + } } catch (RecognitionException &e) { @@ -2179,40 +2678,26 @@ TocParser::LiteralContext* TocParser::literal() { return _localctx; } -//----------------- SubscriptContext ------------------------------------------------------------------ +//----------------- AccessMemberContext ------------------------------------------------------------------ -TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessMemberContext::AccessMemberContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() { - return getRuleContext(0); +TocParser::IdentifierExprContext* TocParser::AccessMemberContext::identifierExpr() { + return getRuleContext(0); } -TocParser::ExprContext* TocParser::SubscriptContext::expr() { - return getRuleContext(0); -} - - -size_t TocParser::SubscriptContext::getRuleIndex() const { - return TocParser::RuleSubscript; -} -void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterSubscript(this); +size_t TocParser::AccessMemberContext::getRuleIndex() const { + return TocParser::RuleAccessMember; } -void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitSubscript(this); -} -TocParser::SubscriptContext* TocParser::subscript() { - SubscriptContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 58, TocParser::RuleSubscript); +TocParser::AccessMemberContext* TocParser::accessMember() { + AccessMemberContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 80, TocParser::RuleAccessMember); + size_t _la = 0; #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2223,14 +2708,19 @@ TocParser::SubscriptContext* TocParser::subscript() { }); try { enterOuterAlt(_localctx, 1); - setState(236); - nonSubscriptExpr(); - setState(237); - match(TocParser::T__13); - setState(238); - expr(); - setState(239); - match(TocParser::T__14); + setState(369); + _la = _input->LA(1); + if (!(_la == TocParser::T__24 + + || _la == TocParser::T__25)) { + _errHandler->recoverInline(this); + } + else { + _errHandler->reportMatch(this); + consume(); + } + setState(370); + identifierExpr(); } catch (RecognitionException &e) { @@ -2242,40 +2732,25 @@ TocParser::SubscriptContext* TocParser::subscript() { return _localctx; } -//----------------- MemberAccessContext ------------------------------------------------------------------ +//----------------- AccessBracketsContext ------------------------------------------------------------------ -TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState) +TocParser::AccessBracketsContext::AccessBracketsContext(ParserRuleContext *parent, size_t invokingState) : ParserRuleContext(parent, invokingState) { } -std::vector TocParser::MemberAccessContext::identifier() { - return getRuleContexts(); -} - -TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) { - return getRuleContext(i); +TocParser::ExprContext* TocParser::AccessBracketsContext::expr() { + return getRuleContext(0); } -size_t TocParser::MemberAccessContext::getRuleIndex() const { - return TocParser::RuleMemberAccess; -} - -void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterMemberAccess(this); +size_t TocParser::AccessBracketsContext::getRuleIndex() const { + return TocParser::RuleAccessBrackets; } -void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitMemberAccess(this); -} -TocParser::MemberAccessContext* TocParser::memberAccess() { - MemberAccessContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 60, TocParser::RuleMemberAccess); +TocParser::AccessBracketsContext* TocParser::accessBrackets() { + AccessBracketsContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 82, TocParser::RuleAccessBrackets); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2286,12 +2761,12 @@ TocParser::MemberAccessContext* TocParser::memberAccess() { }); try { enterOuterAlt(_localctx, 1); - setState(241); - identifier(); - setState(242); - match(TocParser::T__15); - setState(243); - identifier(); + setState(372); + match(TocParser::T__5); + setState(373); + expr(); + setState(374); + match(TocParser::T__6); } catch (RecognitionException &e) { @@ -2318,21 +2793,10 @@ size_t TocParser::ParenExprContext::getRuleIndex() const { return TocParser::RuleParenExpr; } -void TocParser::ParenExprContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterParenExpr(this); -} - -void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitParenExpr(this); -} TocParser::ParenExprContext* TocParser::parenExpr() { ParenExprContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 62, TocParser::RuleParenExpr); + enterRule(_localctx, 84, TocParser::RuleParenExpr); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2343,12 +2807,12 @@ TocParser::ParenExprContext* TocParser::parenExpr() { }); try { enterOuterAlt(_localctx, 1); - setState(245); - match(TocParser::T__4); - setState(246); + setState(376); + match(TocParser::T__8); + setState(377); expr(); - setState(247); - match(TocParser::T__5); + setState(378); + match(TocParser::T__9); } catch (RecognitionException &e) { @@ -2375,21 +2839,10 @@ size_t TocParser::FuncNameContext::getRuleIndex() const { return TocParser::RuleFuncName; } -void TocParser::FuncNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterFuncName(this); -} - -void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitFuncName(this); -} TocParser::FuncNameContext* TocParser::funcName() { FuncNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 64, TocParser::RuleFuncName); + enterRule(_localctx, 86, TocParser::RuleFuncName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2400,7 +2853,7 @@ TocParser::FuncNameContext* TocParser::funcName() { }); try { enterOuterAlt(_localctx, 1); - setState(249); + setState(380); match(TocParser::NAME); } @@ -2428,21 +2881,10 @@ size_t TocParser::VarNameContext::getRuleIndex() const { return TocParser::RuleVarName; } -void TocParser::VarNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterVarName(this); -} - -void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitVarName(this); -} TocParser::VarNameContext* TocParser::varName() { VarNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 66, TocParser::RuleVarName); + enterRule(_localctx, 88, TocParser::RuleVarName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2453,7 +2895,7 @@ TocParser::VarNameContext* TocParser::varName() { }); try { enterOuterAlt(_localctx, 1); - setState(251); + setState(382); match(TocParser::NAME); } @@ -2481,21 +2923,10 @@ size_t TocParser::TypeNameContext::getRuleIndex() const { return TocParser::RuleTypeName; } -void TocParser::TypeNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterTypeName(this); -} - -void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitTypeName(this); -} TocParser::TypeNameContext* TocParser::typeName() { TypeNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 68, TocParser::RuleTypeName); + enterRule(_localctx, 90, TocParser::RuleTypeName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2506,7 +2937,7 @@ TocParser::TypeNameContext* TocParser::typeName() { }); try { enterOuterAlt(_localctx, 1); - setState(253); + setState(384); match(TocParser::NAME); } @@ -2534,21 +2965,10 @@ size_t TocParser::StructNameContext::getRuleIndex() const { return TocParser::RuleStructName; } -void TocParser::StructNameContext::enterRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->enterStructName(this); -} - -void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) { - auto parserListener = dynamic_cast(listener); - if (parserListener != nullptr) - parserListener->exitStructName(this); -} TocParser::StructNameContext* TocParser::structName() { StructNameContext *_localctx = _tracker.createInstance(_ctx, getState()); - enterRule(_localctx, 70, TocParser::RuleStructName); + enterRule(_localctx, 92, TocParser::RuleStructName); #if __cplusplus > 201703L auto onExit = finally([=, this] { @@ -2559,7 +2979,7 @@ TocParser::StructNameContext* TocParser::structName() { }); try { enterOuterAlt(_localctx, 1); - setState(255); + setState(386); match(TocParser::NAME); } @@ -2572,6 +2992,223 @@ TocParser::StructNameContext* TocParser::structName() { return _localctx; } +//----------------- Postfix_opContext ------------------------------------------------------------------ + +TocParser::Postfix_opContext::Postfix_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TocParser::Postfix_opContext::getRuleIndex() const { + return TocParser::RulePostfix_op; +} + + +TocParser::Postfix_opContext* TocParser::postfix_op() { + Postfix_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 94, TocParser::RulePostfix_op); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(388); + _la = _input->LA(1); + if (!(_la == TocParser::T__26 + + || _la == TocParser::T__27)) { + _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; +} + +//----------------- Prefix_opContext ------------------------------------------------------------------ + +TocParser::Prefix_opContext::Prefix_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + +TocParser::Postfix_opContext* TocParser::Prefix_opContext::postfix_op() { + return getRuleContext(0); +} + + +size_t TocParser::Prefix_opContext::getRuleIndex() const { + return TocParser::RulePrefix_op; +} + + +TocParser::Prefix_opContext* TocParser::prefix_op() { + Prefix_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 96, TocParser::RulePrefix_op); + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + setState(397); + _errHandler->sync(this); + switch (_input->LA(1)) { + case TocParser::T__28: { + enterOuterAlt(_localctx, 1); + setState(390); + match(TocParser::T__28); + break; + } + + case TocParser::T__29: { + enterOuterAlt(_localctx, 2); + setState(391); + match(TocParser::T__29); + break; + } + + case TocParser::T__30: { + enterOuterAlt(_localctx, 3); + setState(392); + match(TocParser::T__30); + break; + } + + case TocParser::T__31: { + enterOuterAlt(_localctx, 4); + setState(393); + match(TocParser::T__31); + break; + } + + case TocParser::T__32: { + enterOuterAlt(_localctx, 5); + setState(394); + match(TocParser::T__32); + break; + } + + case TocParser::T__4: { + enterOuterAlt(_localctx, 6); + setState(395); + match(TocParser::T__4); + break; + } + + case TocParser::T__26: + case TocParser::T__27: { + enterOuterAlt(_localctx, 7); + setState(396); + postfix_op(); + break; + } + + default: + throw NoViableAltException(this); + } + + } + catch (RecognitionException &e) { + _errHandler->reportError(this, e); + _localctx->exception = std::current_exception(); + _errHandler->recover(this, _localctx->exception); + } + + return _localctx; +} + +//----------------- Binary_opContext ------------------------------------------------------------------ + +TocParser::Binary_opContext::Binary_opContext(ParserRuleContext *parent, size_t invokingState) + : ParserRuleContext(parent, invokingState) { +} + + +size_t TocParser::Binary_opContext::getRuleIndex() const { + return TocParser::RuleBinary_op; +} + + +TocParser::Binary_opContext* TocParser::binary_op() { + Binary_opContext *_localctx = _tracker.createInstance(_ctx, getState()); + enterRule(_localctx, 98, TocParser::RuleBinary_op); + size_t _la = 0; + +#if __cplusplus > 201703L + auto onExit = finally([=, this] { +#else + auto onExit = finally([=] { +#endif + exitRule(); + }); + try { + enterOuterAlt(_localctx, 1); + setState(399); + _la = _input->LA(1); + if (!((((_la & ~ 0x3fULL) == 0) && + ((1ULL << _la) & ((1ULL << TocParser::T__4) + | (1ULL << TocParser::T__14) + | (1ULL << TocParser::T__15) + | (1ULL << TocParser::T__28) + | (1ULL << TocParser::T__29) + | (1ULL << TocParser::T__32) + | (1ULL << TocParser::T__33) + | (1ULL << TocParser::T__34) + | (1ULL << TocParser::T__35) + | (1ULL << TocParser::T__36) + | (1ULL << TocParser::T__37) + | (1ULL << TocParser::T__38) + | (1ULL << TocParser::T__39) + | (1ULL << TocParser::T__40) + | (1ULL << TocParser::T__41) + | (1ULL << TocParser::T__42) + | (1ULL << TocParser::T__43) + | (1ULL << TocParser::T__44) + | (1ULL << TocParser::T__45) + | (1ULL << TocParser::T__46) + | (1ULL << TocParser::T__47) + | (1ULL << TocParser::T__48) + | (1ULL << TocParser::T__49) + | (1ULL << TocParser::T__50) + | (1ULL << TocParser::T__51) + | (1ULL << TocParser::T__52) + | (1ULL << TocParser::T__53) + | (1ULL << TocParser::T__54))) != 0))) { + _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; +} + // Static vars and initialization. std::vector TocParser::_decisionToDFA; atn::PredictionContextCache TocParser::_sharedContextCache; @@ -2581,22 +3218,33 @@ atn::ATN TocParser::_atn; std::vector TocParser::_serializedATN; std::vector TocParser::_ruleNames = { - "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", - "body", "structDecl", "structMember", "structVar", "structMethod", "stmt", - "conditional", "ifCond", "loop", "whileLoop", "assignment", "returnStmt", - "expr", "nonOpExpr", "nonSubscriptExpr", "nonAccessExpr", "funcCall", - "operatorExpr", "binaryOperator", "identifier", "literal", "subscript", - "memberAccess", "parenExpr", "funcName", "varName", "typeName", "structName" + "prog", "decl", "varDecl", "var", "varInit", "type", "typeModifier", "funcDecl", + "func", "parameter", "body", "structDecl", "structMember", "structVar", + "structMethod", "genericDecl", "stmt", "ifStmt", "elseIfStmt", "elseStmt", + "switchStmt", "switchBody", "switchCase", "forStmt", "whileStmt", "assignStmt", + "returnStmt", "expr", "nonOpExpr", "nonAccessExpr", "funcExpr", "opExpr", + "binaryOp", "prefixOp", "postfixOp", "ternaryOp", "identifierExpr", "litExpr", + "accessExpr", "accessSubExpr", "accessMember", "accessBrackets", "parenExpr", + "funcName", "varName", "typeName", "structName", "postfix_op", "prefix_op", + "binary_op" }; std::vector TocParser::_literalNames = { - "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", - "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'" + "", "';'", "'var'", "':'", "'='", "'*'", "'['", "']'", "'func'", "'('", + "')'", "','", "'{'", "'}'", "'struct'", "'<'", "'>'", "'if'", "'else'", + "'switch'", "'case'", "'for'", "'while'", "'return'", "'\u003F'", "'.'", + "'->'", "'++'", "'--'", "'+'", "'-'", "'!'", "'~'", "'&'", "'/'", "'%'", + "'|'", "'^'", "'=='", "'!='", "'<='", "'>='", "'<<'", "'>>'", "'||'", + "'&&'", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'+='", "'-='", "'*='", + "'/='", "'%='" }; std::vector TocParser::_symbolicNames = { - "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", - "INTLIT", "NAME", "WS", "NEWLINE" + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", + "", "", "INT_LIT", "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", + "NEWLINE" }; dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames); @@ -2619,7 +3267,7 @@ TocParser::Initializer::Initializer() { static const uint16_t serializedATNSegment0[] = { 0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, - 0x3, 0x17, 0x104, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, + 0x3, 0x40, 0x194, 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, @@ -2630,167 +3278,272 @@ TocParser::Initializer::Initializer() { 0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, - 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x3, 0x2, - 0x6, 0x2, 0x4c, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 0x4d, 0x3, 0x2, 0x3, - 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x55, 0xa, 0x3, 0x3, - 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, - 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x60, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, - 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, - 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, - 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x73, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, - 0x76, 0xb, 0x9, 0x5, 0x9, 0x78, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x7, - 0xa, 0x7c, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x7f, 0xb, 0xa, 0x3, 0xa, - 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x87, - 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x8a, 0xb, 0xb, 0x3, 0xb, 0x3, 0xb, - 0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x90, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, - 0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, - 0xf, 0x3, 0xf, 0x5, 0xf, 0x9c, 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, - 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, - 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, - 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, - 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, - 0x16, 0xb8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, - 0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0xc0, 0xa, 0x17, 0x3, 0x18, 0x3, - 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0xc7, 0xa, 0x18, - 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, - 0x5, 0x19, 0xcf, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, - 0x1a, 0x3, 0x1a, 0x7, 0x1a, 0xd6, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, - 0xd9, 0xb, 0x1a, 0x5, 0x1a, 0xdb, 0xa, 0x1a, 0x3, 0x1a, 0x3, 0x1a, - 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, - 0x3, 0x1c, 0x7, 0x1c, 0xe6, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0xe9, - 0xb, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, - 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, - 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, - 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, - 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x2, 0x2, 0x26, 0x2, 0x4, 0x6, 0x8, - 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, - 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, - 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x2, 0x2, 0x2, - 0x104, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4, 0x54, 0x3, 0x2, 0x2, 0x2, - 0x6, 0x56, 0x3, 0x2, 0x2, 0x2, 0x8, 0x59, 0x3, 0x2, 0x2, 0x2, 0xa, - 0x61, 0x3, 0x2, 0x2, 0x2, 0xc, 0x63, 0x3, 0x2, 0x2, 0x2, 0xe, 0x66, - 0x3, 0x2, 0x2, 0x2, 0x10, 0x77, 0x3, 0x2, 0x2, 0x2, 0x12, 0x79, 0x3, - 0x2, 0x2, 0x2, 0x14, 0x82, 0x3, 0x2, 0x2, 0x2, 0x16, 0x8f, 0x3, 0x2, - 0x2, 0x2, 0x18, 0x91, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x93, 0x3, 0x2, 0x2, - 0x2, 0x1c, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x9d, 0x3, 0x2, 0x2, 0x2, - 0x20, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, - 0xa5, 0x3, 0x2, 0x2, 0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xad, - 0x3, 0x2, 0x2, 0x2, 0x2a, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xbf, 0x3, - 0x2, 0x2, 0x2, 0x2e, 0xc6, 0x3, 0x2, 0x2, 0x2, 0x30, 0xce, 0x3, 0x2, - 0x2, 0x2, 0x32, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x34, 0xde, 0x3, 0x2, 0x2, - 0x2, 0x36, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x38, 0xea, 0x3, 0x2, 0x2, 0x2, - 0x3a, 0xec, 0x3, 0x2, 0x2, 0x2, 0x3c, 0xee, 0x3, 0x2, 0x2, 0x2, 0x3e, - 0xf3, 0x3, 0x2, 0x2, 0x2, 0x40, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x42, 0xfb, - 0x3, 0x2, 0x2, 0x2, 0x44, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x46, 0xff, 0x3, - 0x2, 0x2, 0x2, 0x48, 0x101, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4c, 0x5, - 0x4, 0x3, 0x2, 0x4b, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4d, 0x3, 0x2, - 0x2, 0x2, 0x4d, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x3, 0x2, 0x2, - 0x2, 0x4e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x7, 0x2, 0x2, 0x3, - 0x50, 0x3, 0x3, 0x2, 0x2, 0x2, 0x51, 0x55, 0x5, 0x6, 0x4, 0x2, 0x52, - 0x55, 0x5, 0xc, 0x7, 0x2, 0x53, 0x55, 0x5, 0x14, 0xb, 0x2, 0x54, - 0x51, 0x3, 0x2, 0x2, 0x2, 0x54, 0x52, 0x3, 0x2, 0x2, 0x2, 0x54, 0x53, - 0x3, 0x2, 0x2, 0x2, 0x55, 0x5, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x7, - 0x3, 0x2, 0x2, 0x57, 0x58, 0x5, 0x8, 0x5, 0x2, 0x58, 0x7, 0x3, 0x2, - 0x2, 0x2, 0x59, 0x5a, 0x5, 0x44, 0x23, 0x2, 0x5a, 0x5b, 0x7, 0x4, - 0x2, 0x2, 0x5b, 0x5c, 0x5, 0xa, 0x6, 0x2, 0x5c, 0x5f, 0x3, 0x2, 0x2, - 0x2, 0x5d, 0x5e, 0x7, 0x5, 0x2, 0x2, 0x5e, 0x60, 0x5, 0x2a, 0x16, - 0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x60, 0x3, 0x2, 0x2, 0x2, - 0x60, 0x9, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x46, 0x24, 0x2, - 0x62, 0xb, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x7, 0x6, 0x2, 0x2, 0x64, - 0x65, 0x5, 0xe, 0x8, 0x2, 0x65, 0xd, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, - 0x5, 0x42, 0x22, 0x2, 0x67, 0x68, 0x7, 0x7, 0x2, 0x2, 0x68, 0x69, - 0x5, 0x10, 0x9, 0x2, 0x69, 0x6a, 0x7, 0x8, 0x2, 0x2, 0x6a, 0x6b, - 0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, 0x5, 0xa, 0x6, 0x2, 0x6c, 0x6d, 0x3, - 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x12, 0xa, 0x2, 0x6e, 0xf, 0x3, 0x2, - 0x2, 0x2, 0x6f, 0x74, 0x5, 0x8, 0x5, 0x2, 0x70, 0x71, 0x7, 0x9, 0x2, - 0x2, 0x71, 0x73, 0x5, 0x8, 0x5, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, - 0x73, 0x76, 0x3, 0x2, 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, - 0x75, 0x3, 0x2, 0x2, 0x2, 0x75, 0x78, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, - 0x3, 0x2, 0x2, 0x2, 0x77, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, 0x3, - 0x2, 0x2, 0x2, 0x78, 0x11, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7d, 0x7, 0xa, - 0x2, 0x2, 0x7a, 0x7c, 0x5, 0x1c, 0xf, 0x2, 0x7b, 0x7a, 0x3, 0x2, - 0x2, 0x2, 0x7c, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7b, 0x3, 0x2, 0x2, - 0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x80, 0x3, 0x2, 0x2, 0x2, - 0x7f, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0xb, 0x2, 0x2, 0x81, - 0x13, 0x3, 0x2, 0x2, 0x2, 0x82, 0x83, 0x7, 0xc, 0x2, 0x2, 0x83, 0x84, - 0x5, 0x48, 0x25, 0x2, 0x84, 0x88, 0x7, 0xa, 0x2, 0x2, 0x85, 0x87, - 0x5, 0x16, 0xc, 0x2, 0x86, 0x85, 0x3, 0x2, 0x2, 0x2, 0x87, 0x8a, - 0x3, 0x2, 0x2, 0x2, 0x88, 0x86, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x3, - 0x2, 0x2, 0x2, 0x89, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, - 0x2, 0x2, 0x8b, 0x8c, 0x7, 0xb, 0x2, 0x2, 0x8c, 0x15, 0x3, 0x2, 0x2, - 0x2, 0x8d, 0x90, 0x5, 0x18, 0xd, 0x2, 0x8e, 0x90, 0x5, 0x1a, 0xe, - 0x2, 0x8f, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x8e, 0x3, 0x2, 0x2, 0x2, - 0x90, 0x17, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, 0x5, 0x8, 0x5, 0x2, 0x92, - 0x19, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, 0x5, 0xe, 0x8, 0x2, 0x94, 0x1b, - 0x3, 0x2, 0x2, 0x2, 0x95, 0x9c, 0x5, 0x6, 0x4, 0x2, 0x96, 0x9c, 0x5, - 0x1e, 0x10, 0x2, 0x97, 0x9c, 0x5, 0x22, 0x12, 0x2, 0x98, 0x9c, 0x5, - 0x26, 0x14, 0x2, 0x99, 0x9c, 0x5, 0x28, 0x15, 0x2, 0x9a, 0x9c, 0x5, - 0x2a, 0x16, 0x2, 0x9b, 0x95, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x96, 0x3, - 0x2, 0x2, 0x2, 0x9b, 0x97, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x98, 0x3, 0x2, - 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9a, 0x3, 0x2, 0x2, - 0x2, 0x9c, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x20, 0x11, - 0x2, 0x9e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0xd, 0x2, 0x2, - 0xa0, 0xa1, 0x5, 0x2a, 0x16, 0x2, 0xa1, 0xa2, 0x5, 0x12, 0xa, 0x2, - 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 0x13, 0x2, - 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xe, 0x2, 0x2, 0xa6, - 0xa7, 0x5, 0x2a, 0x16, 0x2, 0xa7, 0xa8, 0x5, 0x12, 0xa, 0x2, 0xa8, - 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x38, 0x1d, 0x2, 0xaa, - 0xab, 0x7, 0x5, 0x2, 0x2, 0xab, 0xac, 0x5, 0x2a, 0x16, 0x2, 0xac, - 0x27, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x7, 0xf, 0x2, 0x2, 0xae, 0xaf, - 0x5, 0x2a, 0x16, 0x2, 0xaf, 0x29, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb8, - 0x5, 0x32, 0x1a, 0x2, 0xb1, 0xb8, 0x5, 0x3a, 0x1e, 0x2, 0xb2, 0xb8, - 0x5, 0x38, 0x1d, 0x2, 0xb3, 0xb8, 0x5, 0x3c, 0x1f, 0x2, 0xb4, 0xb8, - 0x5, 0x3e, 0x20, 0x2, 0xb5, 0xb8, 0x5, 0x40, 0x21, 0x2, 0xb6, 0xb8, - 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb1, - 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb3, 0x3, - 0x2, 0x2, 0x2, 0xb7, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb5, 0x3, 0x2, - 0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x2b, 0x3, 0x2, 0x2, - 0x2, 0xb9, 0xc0, 0x5, 0x32, 0x1a, 0x2, 0xba, 0xc0, 0x5, 0x3a, 0x1e, - 0x2, 0xbb, 0xc0, 0x5, 0x38, 0x1d, 0x2, 0xbc, 0xc0, 0x5, 0x3c, 0x1f, - 0x2, 0xbd, 0xc0, 0x5, 0x3e, 0x20, 0x2, 0xbe, 0xc0, 0x5, 0x40, 0x21, - 0x2, 0xbf, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xba, 0x3, 0x2, 0x2, 0x2, - 0xbf, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbf, - 0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0x2d, - 0x3, 0x2, 0x2, 0x2, 0xc1, 0xc7, 0x5, 0x32, 0x1a, 0x2, 0xc2, 0xc7, - 0x5, 0x3a, 0x1e, 0x2, 0xc3, 0xc7, 0x5, 0x38, 0x1d, 0x2, 0xc4, 0xc7, - 0x5, 0x3e, 0x20, 0x2, 0xc5, 0xc7, 0x5, 0x40, 0x21, 0x2, 0xc6, 0xc1, - 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc3, 0x3, - 0x2, 0x2, 0x2, 0xc6, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc5, 0x3, 0x2, - 0x2, 0x2, 0xc7, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xcf, 0x5, 0x32, - 0x1a, 0x2, 0xc9, 0xcf, 0x5, 0x3a, 0x1e, 0x2, 0xca, 0xcf, 0x5, 0x38, - 0x1d, 0x2, 0xcb, 0xcf, 0x5, 0x3c, 0x1f, 0x2, 0xcc, 0xcf, 0x5, 0x40, - 0x21, 0x2, 0xcd, 0xcf, 0x5, 0x34, 0x1b, 0x2, 0xce, 0xc8, 0x3, 0x2, - 0x2, 0x2, 0xce, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xce, 0xca, 0x3, 0x2, 0x2, - 0x2, 0xce, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcc, 0x3, 0x2, 0x2, 0x2, - 0xce, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x31, 0x3, 0x2, 0x2, 0x2, 0xd0, - 0xd1, 0x5, 0x42, 0x22, 0x2, 0xd1, 0xda, 0x7, 0x7, 0x2, 0x2, 0xd2, - 0xd7, 0x5, 0x2a, 0x16, 0x2, 0xd3, 0xd4, 0x7, 0x9, 0x2, 0x2, 0xd4, - 0xd6, 0x5, 0x2a, 0x16, 0x2, 0xd5, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xd6, - 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, - 0x3, 0x2, 0x2, 0x2, 0xd8, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xd7, 0x3, - 0x2, 0x2, 0x2, 0xda, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, - 0x2, 0x2, 0xdb, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x8, 0x2, - 0x2, 0xdd, 0x33, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x5, 0x36, 0x1c, - 0x2, 0xdf, 0x35, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x5, 0x2c, 0x17, - 0x2, 0xe1, 0xe2, 0x7, 0x13, 0x2, 0x2, 0xe2, 0xe7, 0x5, 0x2c, 0x17, - 0x2, 0xe3, 0xe4, 0x7, 0x13, 0x2, 0x2, 0xe4, 0xe6, 0x5, 0x2c, 0x17, - 0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe9, 0x3, 0x2, 0x2, 0x2, - 0xe7, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, - 0x37, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, - 0x5, 0x44, 0x23, 0x2, 0xeb, 0x39, 0x3, 0x2, 0x2, 0x2, 0xec, 0xed, - 0x7, 0x14, 0x2, 0x2, 0xed, 0x3b, 0x3, 0x2, 0x2, 0x2, 0xee, 0xef, - 0x5, 0x2e, 0x18, 0x2, 0xef, 0xf0, 0x7, 0x10, 0x2, 0x2, 0xf0, 0xf1, - 0x5, 0x2a, 0x16, 0x2, 0xf1, 0xf2, 0x7, 0x11, 0x2, 0x2, 0xf2, 0x3d, - 0x3, 0x2, 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x38, 0x1d, 0x2, 0xf4, 0xf5, - 0x7, 0x12, 0x2, 0x2, 0xf5, 0xf6, 0x5, 0x38, 0x1d, 0x2, 0xf6, 0x3f, - 0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x7, 0x7, 0x2, 0x2, 0xf8, 0xf9, 0x5, - 0x2a, 0x16, 0x2, 0xf9, 0xfa, 0x7, 0x8, 0x2, 0x2, 0xfa, 0x41, 0x3, - 0x2, 0x2, 0x2, 0xfb, 0xfc, 0x7, 0x15, 0x2, 0x2, 0xfc, 0x43, 0x3, - 0x2, 0x2, 0x2, 0xfd, 0xfe, 0x7, 0x15, 0x2, 0x2, 0xfe, 0x45, 0x3, - 0x2, 0x2, 0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x47, 0x3, - 0x2, 0x2, 0x2, 0x101, 0x102, 0x7, 0x15, 0x2, 0x2, 0x102, 0x49, 0x3, - 0x2, 0x2, 0x2, 0x12, 0x4d, 0x54, 0x5f, 0x74, 0x77, 0x7d, 0x88, 0x8f, - 0x9b, 0xb7, 0xbf, 0xc6, 0xce, 0xd7, 0xda, 0xe7, + 0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, + 0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, + 0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 0x2c, + 0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, + 0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, + 0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x3, 0x2, 0x6, 0x2, 0x68, 0xa, 0x2, + 0xd, 0x2, 0xe, 0x2, 0x69, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, + 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x73, 0xa, 0x3, 0x3, 0x4, + 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, + 0x5, 0x3, 0x5, 0x5, 0x5, 0x7e, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, + 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, + 0x7, 0x7, 0x89, 0xa, 0x7, 0xc, 0x7, 0xe, 0x7, 0x8c, 0xb, 0x7, 0x3, + 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x91, 0xa, 0x8, 0x3, 0x8, 0x5, + 0x8, 0x94, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, + 0xa, 0x5, 0xa, 0x9b, 0xa, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, + 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, + 0x3, 0xb, 0x7, 0xb, 0xa8, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0xab, 0xb, + 0xb, 0x5, 0xb, 0xad, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0xb1, + 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0xb4, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, + 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0xbb, 0xa, 0xd, 0x3, 0xd, + 0x3, 0xd, 0x7, 0xd, 0xbf, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0xc2, 0xb, + 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x5, 0xe, 0xc8, 0xa, + 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, + 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x7, 0x11, 0xd3, 0xa, 0x11, 0xc, + 0x11, 0xe, 0x11, 0xd6, 0xb, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, + 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0xea, 0xa, 0x12, 0x3, + 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x7, 0x13, 0xf0, 0xa, 0x13, + 0xc, 0x13, 0xe, 0x13, 0xf3, 0xb, 0x13, 0x3, 0x13, 0x5, 0x13, 0xf6, + 0xa, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, + 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, + 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x7, 0x17, 0x106, 0xa, 0x17, 0xc, + 0x17, 0xe, 0x17, 0x109, 0xb, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, + 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, + 0x5, 0x19, 0x114, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, + 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, + 0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, + 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, + 0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x12d, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, + 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x134, 0xa, 0x1e, 0x3, + 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x5, 0x1f, 0x139, 0xa, 0x1f, 0x3, 0x20, + 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x7, 0x20, 0x140, 0xa, + 0x20, 0xc, 0x20, 0xe, 0x20, 0x143, 0xb, 0x20, 0x5, 0x20, 0x145, 0xa, + 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, + 0x21, 0x5, 0x21, 0x14d, 0xa, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, + 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x7, 0x22, 0x155, 0xa, 0x22, 0xc, + 0x22, 0xe, 0x22, 0x158, 0xb, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, + 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, + 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, + 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x6, 0x28, 0x16c, 0xa, 0x28, 0xd, + 0x28, 0xe, 0x28, 0x16d, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x172, 0xa, + 0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, + 0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, + 0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, + 0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x32, 0x3, 0x32, 0x3, + 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x190, + 0xa, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x2, 0x2, 0x34, 0x2, + 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, + 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, + 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, + 0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, + 0x5e, 0x60, 0x62, 0x64, 0x2, 0x6, 0x3, 0x2, 0x3a, 0x3d, 0x3, 0x2, + 0x1b, 0x1c, 0x3, 0x2, 0x1d, 0x1e, 0x6, 0x2, 0x7, 0x7, 0x11, 0x12, + 0x1f, 0x20, 0x23, 0x39, 0x2, 0x194, 0x2, 0x67, 0x3, 0x2, 0x2, 0x2, + 0x4, 0x72, 0x3, 0x2, 0x2, 0x2, 0x6, 0x74, 0x3, 0x2, 0x2, 0x2, 0x8, + 0x77, 0x3, 0x2, 0x2, 0x2, 0xa, 0x7f, 0x3, 0x2, 0x2, 0x2, 0xc, 0x86, + 0x3, 0x2, 0x2, 0x2, 0xe, 0x93, 0x3, 0x2, 0x2, 0x2, 0x10, 0x95, 0x3, + 0x2, 0x2, 0x2, 0x12, 0x98, 0x3, 0x2, 0x2, 0x2, 0x14, 0xac, 0x3, 0x2, + 0x2, 0x2, 0x16, 0xae, 0x3, 0x2, 0x2, 0x2, 0x18, 0xb7, 0x3, 0x2, 0x2, + 0x2, 0x1a, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x1c, 0xc9, 0x3, 0x2, 0x2, 0x2, + 0x1e, 0xcc, 0x3, 0x2, 0x2, 0x2, 0x20, 0xce, 0x3, 0x2, 0x2, 0x2, 0x22, + 0xe9, 0x3, 0x2, 0x2, 0x2, 0x24, 0xeb, 0x3, 0x2, 0x2, 0x2, 0x26, 0xf7, + 0x3, 0x2, 0x2, 0x2, 0x28, 0xfc, 0x3, 0x2, 0x2, 0x2, 0x2a, 0xff, 0x3, + 0x2, 0x2, 0x2, 0x2c, 0x103, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x10c, 0x3, + 0x2, 0x2, 0x2, 0x30, 0x110, 0x3, 0x2, 0x2, 0x2, 0x32, 0x11b, 0x3, + 0x2, 0x2, 0x2, 0x34, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x36, 0x123, 0x3, + 0x2, 0x2, 0x2, 0x38, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x133, 0x3, + 0x2, 0x2, 0x2, 0x3c, 0x138, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x13a, 0x3, + 0x2, 0x2, 0x2, 0x40, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x42, 0x14e, 0x3, + 0x2, 0x2, 0x2, 0x44, 0x159, 0x3, 0x2, 0x2, 0x2, 0x46, 0x15c, 0x3, + 0x2, 0x2, 0x2, 0x48, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x165, 0x3, + 0x2, 0x2, 0x2, 0x4c, 0x167, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x169, 0x3, + 0x2, 0x2, 0x2, 0x50, 0x171, 0x3, 0x2, 0x2, 0x2, 0x52, 0x173, 0x3, + 0x2, 0x2, 0x2, 0x54, 0x176, 0x3, 0x2, 0x2, 0x2, 0x56, 0x17a, 0x3, + 0x2, 0x2, 0x2, 0x58, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x180, 0x3, + 0x2, 0x2, 0x2, 0x5c, 0x182, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x184, 0x3, + 0x2, 0x2, 0x2, 0x60, 0x186, 0x3, 0x2, 0x2, 0x2, 0x62, 0x18f, 0x3, + 0x2, 0x2, 0x2, 0x64, 0x191, 0x3, 0x2, 0x2, 0x2, 0x66, 0x68, 0x5, + 0x4, 0x3, 0x2, 0x67, 0x66, 0x3, 0x2, 0x2, 0x2, 0x68, 0x69, 0x3, 0x2, + 0x2, 0x2, 0x69, 0x67, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, 0x3, 0x2, 0x2, + 0x2, 0x6a, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x6c, 0x7, 0x2, 0x2, 0x3, + 0x6c, 0x3, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x6, 0x4, 0x2, 0x6e, + 0x6f, 0x7, 0x3, 0x2, 0x2, 0x6f, 0x73, 0x3, 0x2, 0x2, 0x2, 0x70, 0x73, + 0x5, 0x10, 0x9, 0x2, 0x71, 0x73, 0x5, 0x18, 0xd, 0x2, 0x72, 0x6d, + 0x3, 0x2, 0x2, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, 0x72, 0x71, 0x3, + 0x2, 0x2, 0x2, 0x73, 0x5, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 0x7, 0x4, + 0x2, 0x2, 0x75, 0x76, 0x5, 0x8, 0x5, 0x2, 0x76, 0x7, 0x3, 0x2, 0x2, + 0x2, 0x77, 0x78, 0x5, 0x5a, 0x2e, 0x2, 0x78, 0x79, 0x7, 0x5, 0x2, + 0x2, 0x79, 0x7a, 0x5, 0xc, 0x7, 0x2, 0x7a, 0x7d, 0x3, 0x2, 0x2, 0x2, + 0x7b, 0x7c, 0x7, 0x6, 0x2, 0x2, 0x7c, 0x7e, 0x5, 0x38, 0x1d, 0x2, + 0x7d, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, + 0x9, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x80, 0x5, 0x5a, 0x2e, 0x2, 0x80, + 0x81, 0x7, 0x5, 0x2, 0x2, 0x81, 0x82, 0x5, 0xc, 0x7, 0x2, 0x82, 0x83, + 0x3, 0x2, 0x2, 0x2, 0x83, 0x84, 0x7, 0x6, 0x2, 0x2, 0x84, 0x85, 0x5, + 0x38, 0x1d, 0x2, 0x85, 0xb, 0x3, 0x2, 0x2, 0x2, 0x86, 0x8a, 0x5, + 0x5c, 0x2f, 0x2, 0x87, 0x89, 0x5, 0xe, 0x8, 0x2, 0x88, 0x87, 0x3, + 0x2, 0x2, 0x2, 0x89, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, + 0x2, 0x2, 0x8a, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8b, 0xd, 0x3, 0x2, 0x2, + 0x2, 0x8c, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x94, 0x7, 0x7, 0x2, 0x2, + 0x8e, 0x90, 0x7, 0x8, 0x2, 0x2, 0x8f, 0x91, 0x7, 0x3a, 0x2, 0x2, + 0x90, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x90, 0x91, 0x3, 0x2, 0x2, 0x2, 0x91, + 0x92, 0x3, 0x2, 0x2, 0x2, 0x92, 0x94, 0x7, 0x9, 0x2, 0x2, 0x93, 0x8d, + 0x3, 0x2, 0x2, 0x2, 0x93, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x94, 0xf, 0x3, + 0x2, 0x2, 0x2, 0x95, 0x96, 0x7, 0xa, 0x2, 0x2, 0x96, 0x97, 0x5, 0x12, + 0xa, 0x2, 0x97, 0x11, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9a, 0x5, 0x58, + 0x2d, 0x2, 0x99, 0x9b, 0x5, 0x20, 0x11, 0x2, 0x9a, 0x99, 0x3, 0x2, + 0x2, 0x2, 0x9a, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9c, 0x3, 0x2, 0x2, + 0x2, 0x9c, 0x9d, 0x7, 0xb, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x14, 0xb, + 0x2, 0x9e, 0x9f, 0x7, 0xc, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0x5, 0x2, 0x2, + 0xa0, 0xa1, 0x5, 0xc, 0x7, 0x2, 0xa1, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa2, + 0xa3, 0x5, 0x16, 0xc, 0x2, 0xa3, 0x13, 0x3, 0x2, 0x2, 0x2, 0xa4, + 0xa9, 0x5, 0x8, 0x5, 0x2, 0xa5, 0xa6, 0x7, 0xd, 0x2, 0x2, 0xa6, 0xa8, + 0x5, 0x8, 0x5, 0x2, 0xa7, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa8, 0xab, 0x3, + 0x2, 0x2, 0x2, 0xa9, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x3, 0x2, + 0x2, 0x2, 0xaa, 0xad, 0x3, 0x2, 0x2, 0x2, 0xab, 0xa9, 0x3, 0x2, 0x2, + 0x2, 0xac, 0xa4, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x3, 0x2, 0x2, 0x2, + 0xad, 0x15, 0x3, 0x2, 0x2, 0x2, 0xae, 0xb2, 0x7, 0xe, 0x2, 0x2, 0xaf, + 0xb1, 0x5, 0x22, 0x12, 0x2, 0xb0, 0xaf, 0x3, 0x2, 0x2, 0x2, 0xb1, + 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, + 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb4, 0xb2, 0x3, + 0x2, 0x2, 0x2, 0xb5, 0xb6, 0x7, 0xf, 0x2, 0x2, 0xb6, 0x17, 0x3, 0x2, + 0x2, 0x2, 0xb7, 0xb8, 0x7, 0x10, 0x2, 0x2, 0xb8, 0xba, 0x5, 0x5e, + 0x30, 0x2, 0xb9, 0xbb, 0x5, 0x20, 0x11, 0x2, 0xba, 0xb9, 0x3, 0x2, + 0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, 0x3, 0x2, 0x2, + 0x2, 0xbc, 0xc0, 0x7, 0xe, 0x2, 0x2, 0xbd, 0xbf, 0x5, 0x1a, 0xe, + 0x2, 0xbe, 0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc2, 0x3, 0x2, 0x2, 0x2, + 0xc0, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc1, + 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc2, 0xc0, 0x3, 0x2, 0x2, 0x2, 0xc3, 0xc4, + 0x7, 0xf, 0x2, 0x2, 0xc4, 0x19, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc8, 0x5, + 0x1c, 0xf, 0x2, 0xc6, 0xc8, 0x5, 0x1e, 0x10, 0x2, 0xc7, 0xc5, 0x3, + 0x2, 0x2, 0x2, 0xc7, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc8, 0x1b, 0x3, 0x2, + 0x2, 0x2, 0xc9, 0xca, 0x5, 0x8, 0x5, 0x2, 0xca, 0xcb, 0x7, 0x3, 0x2, + 0x2, 0xcb, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcd, 0x5, 0x12, 0xa, + 0x2, 0xcd, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcf, 0x7, 0x11, 0x2, + 0x2, 0xcf, 0xd4, 0x5, 0x5c, 0x2f, 0x2, 0xd0, 0xd1, 0x7, 0xd, 0x2, + 0x2, 0xd1, 0xd3, 0x5, 0x5c, 0x2f, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, + 0x2, 0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, + 0xd4, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd6, + 0xd4, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x7, 0x12, 0x2, 0x2, 0xd8, + 0x21, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x5, 0x6, 0x4, 0x2, 0xda, 0xdb, + 0x7, 0x3, 0x2, 0x2, 0xdb, 0xea, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xea, 0x5, + 0x24, 0x13, 0x2, 0xdd, 0xea, 0x5, 0x2a, 0x16, 0x2, 0xde, 0xea, 0x5, + 0x30, 0x19, 0x2, 0xdf, 0xea, 0x5, 0x32, 0x1a, 0x2, 0xe0, 0xe1, 0x5, + 0x34, 0x1b, 0x2, 0xe1, 0xe2, 0x7, 0x3, 0x2, 0x2, 0xe2, 0xea, 0x3, + 0x2, 0x2, 0x2, 0xe3, 0xe4, 0x5, 0x36, 0x1c, 0x2, 0xe4, 0xe5, 0x7, + 0x3, 0x2, 0x2, 0xe5, 0xea, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x5, 0x38, + 0x1d, 0x2, 0xe7, 0xe8, 0x7, 0x3, 0x2, 0x2, 0xe8, 0xea, 0x3, 0x2, + 0x2, 0x2, 0xe9, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xdc, 0x3, 0x2, 0x2, + 0x2, 0xe9, 0xdd, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xde, 0x3, 0x2, 0x2, 0x2, + 0xe9, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe9, + 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe6, 0x3, 0x2, 0x2, 0x2, 0xea, 0x23, + 0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, 0x7, 0x13, 0x2, 0x2, 0xec, 0xed, + 0x5, 0x38, 0x1d, 0x2, 0xed, 0xf1, 0x5, 0x16, 0xc, 0x2, 0xee, 0xf0, + 0x5, 0x26, 0x14, 0x2, 0xef, 0xee, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf3, + 0x3, 0x2, 0x2, 0x2, 0xf1, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, + 0x2, 0x2, 0x2, 0xf2, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xf3, 0xf1, 0x3, 0x2, + 0x2, 0x2, 0xf4, 0xf6, 0x5, 0x28, 0x15, 0x2, 0xf5, 0xf4, 0x3, 0x2, + 0x2, 0x2, 0xf5, 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x25, 0x3, 0x2, 0x2, + 0x2, 0xf7, 0xf8, 0x7, 0x14, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x13, 0x2, + 0x2, 0xf9, 0xfa, 0x5, 0x38, 0x1d, 0x2, 0xfa, 0xfb, 0x5, 0x16, 0xc, + 0x2, 0xfb, 0x27, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x14, 0x2, + 0x2, 0xfd, 0xfe, 0x5, 0x16, 0xc, 0x2, 0xfe, 0x29, 0x3, 0x2, 0x2, + 0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x101, 0x5, 0x4a, 0x26, + 0x2, 0x101, 0x102, 0x5, 0x2c, 0x17, 0x2, 0x102, 0x2b, 0x3, 0x2, 0x2, + 0x2, 0x103, 0x107, 0x7, 0xe, 0x2, 0x2, 0x104, 0x106, 0x5, 0x2e, 0x18, + 0x2, 0x105, 0x104, 0x3, 0x2, 0x2, 0x2, 0x106, 0x109, 0x3, 0x2, 0x2, + 0x2, 0x107, 0x105, 0x3, 0x2, 0x2, 0x2, 0x107, 0x108, 0x3, 0x2, 0x2, + 0x2, 0x108, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x109, 0x107, 0x3, 0x2, 0x2, + 0x2, 0x10a, 0x10b, 0x7, 0xf, 0x2, 0x2, 0x10b, 0x2d, 0x3, 0x2, 0x2, + 0x2, 0x10c, 0x10d, 0x7, 0x16, 0x2, 0x2, 0x10d, 0x10e, 0x5, 0x38, + 0x1d, 0x2, 0x10e, 0x10f, 0x5, 0x16, 0xc, 0x2, 0x10f, 0x2f, 0x3, 0x2, + 0x2, 0x2, 0x110, 0x113, 0x7, 0x17, 0x2, 0x2, 0x111, 0x114, 0x5, 0xa, + 0x6, 0x2, 0x112, 0x114, 0x5, 0x34, 0x1b, 0x2, 0x113, 0x111, 0x3, + 0x2, 0x2, 0x2, 0x113, 0x112, 0x3, 0x2, 0x2, 0x2, 0x114, 0x115, 0x3, + 0x2, 0x2, 0x2, 0x115, 0x116, 0x7, 0xd, 0x2, 0x2, 0x116, 0x117, 0x5, + 0x38, 0x1d, 0x2, 0x117, 0x118, 0x7, 0xd, 0x2, 0x2, 0x118, 0x119, + 0x5, 0x38, 0x1d, 0x2, 0x119, 0x11a, 0x5, 0x16, 0xc, 0x2, 0x11a, 0x31, + 0x3, 0x2, 0x2, 0x2, 0x11b, 0x11c, 0x7, 0x18, 0x2, 0x2, 0x11c, 0x11d, + 0x5, 0x38, 0x1d, 0x2, 0x11d, 0x11e, 0x5, 0x16, 0xc, 0x2, 0x11e, 0x33, + 0x3, 0x2, 0x2, 0x2, 0x11f, 0x120, 0x5, 0x4a, 0x26, 0x2, 0x120, 0x121, + 0x7, 0x6, 0x2, 0x2, 0x121, 0x122, 0x5, 0x38, 0x1d, 0x2, 0x122, 0x35, + 0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x7, 0x19, 0x2, 0x2, 0x124, 0x125, + 0x5, 0x38, 0x1d, 0x2, 0x125, 0x37, 0x3, 0x2, 0x2, 0x2, 0x126, 0x12d, + 0x5, 0x3e, 0x20, 0x2, 0x127, 0x12d, 0x5, 0x4c, 0x27, 0x2, 0x128, + 0x12d, 0x5, 0x4a, 0x26, 0x2, 0x129, 0x12d, 0x5, 0x56, 0x2c, 0x2, + 0x12a, 0x12d, 0x5, 0x4e, 0x28, 0x2, 0x12b, 0x12d, 0x5, 0x40, 0x21, + 0x2, 0x12c, 0x126, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x127, 0x3, 0x2, 0x2, + 0x2, 0x12c, 0x128, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x129, 0x3, 0x2, 0x2, + 0x2, 0x12c, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x12b, 0x3, 0x2, 0x2, + 0x2, 0x12d, 0x39, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x134, 0x5, 0x3e, 0x20, + 0x2, 0x12f, 0x134, 0x5, 0x4c, 0x27, 0x2, 0x130, 0x134, 0x5, 0x4a, + 0x26, 0x2, 0x131, 0x134, 0x5, 0x56, 0x2c, 0x2, 0x132, 0x134, 0x5, + 0x4e, 0x28, 0x2, 0x133, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x133, 0x12f, + 0x3, 0x2, 0x2, 0x2, 0x133, 0x130, 0x3, 0x2, 0x2, 0x2, 0x133, 0x131, + 0x3, 0x2, 0x2, 0x2, 0x133, 0x132, 0x3, 0x2, 0x2, 0x2, 0x134, 0x3b, + 0x3, 0x2, 0x2, 0x2, 0x135, 0x139, 0x5, 0x3e, 0x20, 0x2, 0x136, 0x139, + 0x5, 0x4a, 0x26, 0x2, 0x137, 0x139, 0x5, 0x56, 0x2c, 0x2, 0x138, + 0x135, 0x3, 0x2, 0x2, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2, 0x2, 0x138, + 0x137, 0x3, 0x2, 0x2, 0x2, 0x139, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x13a, + 0x13b, 0x5, 0x58, 0x2d, 0x2, 0x13b, 0x144, 0x7, 0xb, 0x2, 0x2, 0x13c, + 0x141, 0x5, 0x38, 0x1d, 0x2, 0x13d, 0x13e, 0x7, 0xd, 0x2, 0x2, 0x13e, + 0x140, 0x5, 0x38, 0x1d, 0x2, 0x13f, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x140, + 0x143, 0x3, 0x2, 0x2, 0x2, 0x141, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x141, + 0x142, 0x3, 0x2, 0x2, 0x2, 0x142, 0x145, 0x3, 0x2, 0x2, 0x2, 0x143, + 0x141, 0x3, 0x2, 0x2, 0x2, 0x144, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x144, + 0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, 0x3, 0x2, 0x2, 0x2, 0x146, + 0x147, 0x7, 0xc, 0x2, 0x2, 0x147, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x148, + 0x14d, 0x5, 0x42, 0x22, 0x2, 0x149, 0x14d, 0x5, 0x44, 0x23, 0x2, + 0x14a, 0x14d, 0x5, 0x46, 0x24, 0x2, 0x14b, 0x14d, 0x5, 0x48, 0x25, + 0x2, 0x14c, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x149, 0x3, 0x2, 0x2, + 0x2, 0x14c, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14b, 0x3, 0x2, 0x2, + 0x2, 0x14d, 0x41, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x14f, 0x5, 0x3a, 0x1e, + 0x2, 0x14f, 0x150, 0x5, 0x64, 0x33, 0x2, 0x150, 0x156, 0x5, 0x3a, + 0x1e, 0x2, 0x151, 0x152, 0x5, 0x64, 0x33, 0x2, 0x152, 0x153, 0x5, + 0x3a, 0x1e, 0x2, 0x153, 0x155, 0x3, 0x2, 0x2, 0x2, 0x154, 0x151, + 0x3, 0x2, 0x2, 0x2, 0x155, 0x158, 0x3, 0x2, 0x2, 0x2, 0x156, 0x154, + 0x3, 0x2, 0x2, 0x2, 0x156, 0x157, 0x3, 0x2, 0x2, 0x2, 0x157, 0x43, + 0x3, 0x2, 0x2, 0x2, 0x158, 0x156, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15a, + 0x5, 0x62, 0x32, 0x2, 0x15a, 0x15b, 0x5, 0x3a, 0x1e, 0x2, 0x15b, + 0x45, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x5, 0x3a, 0x1e, 0x2, 0x15d, + 0x15e, 0x5, 0x60, 0x31, 0x2, 0x15e, 0x47, 0x3, 0x2, 0x2, 0x2, 0x15f, + 0x160, 0x5, 0x3a, 0x1e, 0x2, 0x160, 0x161, 0x7, 0x1a, 0x2, 0x2, 0x161, + 0x162, 0x5, 0x38, 0x1d, 0x2, 0x162, 0x163, 0x7, 0x5, 0x2, 0x2, 0x163, + 0x164, 0x5, 0x38, 0x1d, 0x2, 0x164, 0x49, 0x3, 0x2, 0x2, 0x2, 0x165, + 0x166, 0x5, 0x5a, 0x2e, 0x2, 0x166, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x167, + 0x168, 0x9, 0x2, 0x2, 0x2, 0x168, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x169, + 0x16b, 0x5, 0x3c, 0x1f, 0x2, 0x16a, 0x16c, 0x5, 0x50, 0x29, 0x2, + 0x16b, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16d, 0x3, 0x2, 0x2, 0x2, + 0x16d, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e, 0x3, 0x2, 0x2, 0x2, + 0x16e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x172, 0x5, 0x52, 0x2a, 0x2, + 0x170, 0x172, 0x5, 0x54, 0x2b, 0x2, 0x171, 0x16f, 0x3, 0x2, 0x2, + 0x2, 0x171, 0x170, 0x3, 0x2, 0x2, 0x2, 0x172, 0x51, 0x3, 0x2, 0x2, + 0x2, 0x173, 0x174, 0x9, 0x3, 0x2, 0x2, 0x174, 0x175, 0x5, 0x4a, 0x26, + 0x2, 0x175, 0x53, 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x7, 0x8, 0x2, + 0x2, 0x177, 0x178, 0x5, 0x38, 0x1d, 0x2, 0x178, 0x179, 0x7, 0x9, + 0x2, 0x2, 0x179, 0x55, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x17b, 0x7, 0xb, + 0x2, 0x2, 0x17b, 0x17c, 0x5, 0x38, 0x1d, 0x2, 0x17c, 0x17d, 0x7, + 0xc, 0x2, 0x2, 0x17d, 0x57, 0x3, 0x2, 0x2, 0x2, 0x17e, 0x17f, 0x7, + 0x3e, 0x2, 0x2, 0x17f, 0x59, 0x3, 0x2, 0x2, 0x2, 0x180, 0x181, 0x7, + 0x3e, 0x2, 0x2, 0x181, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x182, 0x183, 0x7, + 0x3e, 0x2, 0x2, 0x183, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x184, 0x185, 0x7, + 0x3e, 0x2, 0x2, 0x185, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x9, + 0x4, 0x2, 0x2, 0x187, 0x61, 0x3, 0x2, 0x2, 0x2, 0x188, 0x190, 0x7, + 0x1f, 0x2, 0x2, 0x189, 0x190, 0x7, 0x20, 0x2, 0x2, 0x18a, 0x190, + 0x7, 0x21, 0x2, 0x2, 0x18b, 0x190, 0x7, 0x22, 0x2, 0x2, 0x18c, 0x190, + 0x7, 0x23, 0x2, 0x2, 0x18d, 0x190, 0x7, 0x7, 0x2, 0x2, 0x18e, 0x190, + 0x5, 0x60, 0x31, 0x2, 0x18f, 0x188, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x189, + 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18b, + 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18c, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18d, + 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x190, 0x63, + 0x3, 0x2, 0x2, 0x2, 0x191, 0x192, 0x9, 0x5, 0x2, 0x2, 0x192, 0x65, + 0x3, 0x2, 0x2, 0x2, 0x1f, 0x69, 0x72, 0x7d, 0x8a, 0x90, 0x93, 0x9a, + 0xa9, 0xac, 0xb2, 0xba, 0xc0, 0xc7, 0xd4, 0xe9, 0xf1, 0xf5, 0x107, + 0x113, 0x12c, 0x133, 0x138, 0x141, 0x144, 0x14c, 0x156, 0x16d, 0x171, + 0x18f, }; _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,