gitweb.ps.run Git - toc/blob - gen/TocParser.cpp

   1 \r
   2 // Generated from Toc.g4 by ANTLR 4.9.2\r
   3 \r
   4 \r
   5 \r
   6 #include "TocParser.h"\r
   7 \r
   8 \r
   9 using namespace antlrcpp;\r
  10 using namespace antlr4;\r
  11 \r
  12 TocParser::TocParser(TokenStream *input) : Parser(input) {\r
  13   _interpreter = new atn::ParserATNSimulator(this, _atn, _decisionToDFA, _sharedContextCache);\r
  14 }\r
  15 \r
  16 TocParser::~TocParser() {\r
  17   delete _interpreter;\r
  18 }\r
  19 \r
  20 std::string TocParser::getGrammarFileName() const {\r
  21   return "Toc.g4";\r
  22 }\r
  23 \r
  24 const std::vector<std::string>& TocParser::getRuleNames() const {\r
  25   return _ruleNames;\r
  26 }\r
  27 \r
  28 dfa::Vocabulary& TocParser::getVocabulary() const {\r
  29   return _vocabulary;\r
  30 }\r
  31 \r
  32 \r
  33 //----------------- ProgContext ------------------------------------------------------------------\r
  34 \r
  35 TocParser::ProgContext::ProgContext(ParserRuleContext *parent, size_t invokingState)\r
  36   : ParserRuleContext(parent, invokingState) {\r
  37 }\r
  38 \r
  39 tree::TerminalNode* TocParser::ProgContext::EOF() {\r
  40   return getToken(TocParser::EOF, 0);\r
  41 }\r
  42 \r
  43 std::vector<TocParser::DeclContext *> TocParser::ProgContext::decl() {\r
  44   return getRuleContexts<TocParser::DeclContext>();\r
  45 }\r
  46 \r
  47 TocParser::DeclContext* TocParser::ProgContext::decl(size_t i) {\r
  48   return getRuleContext<TocParser::DeclContext>(i);\r
  49 }\r
  50 \r
  51 \r
  52 size_t TocParser::ProgContext::getRuleIndex() const {\r
  53   return TocParser::RuleProg;\r
  54 }\r
  55 \r
  56 \r
  57 TocParser::ProgContext* TocParser::prog() {\r
  58   ProgContext *_localctx = _tracker.createInstance<ProgContext>(_ctx, getState());\r
  59   enterRule(_localctx, 0, TocParser::RuleProg);\r
  60   size_t _la = 0;\r
  61 \r
  62 #if __cplusplus > 201703L\r
  63   auto onExit = finally([=, this] {\r
  64 #else\r
  65   auto onExit = finally([=] {\r
  66 #endif\r
  67     exitRule();\r
  68   });\r
  69   try {\r
  70     enterOuterAlt(_localctx, 1);\r
  71     setState(101); \r
  72     _errHandler->sync(this);\r
  73     _la = _input->LA(1);\r
  74     do {\r
  75       setState(100);\r
  76       decl();\r
  77       setState(103); \r
  78       _errHandler->sync(this);\r
  79       _la = _input->LA(1);\r
  80     } while ((((_la & ~ 0x3fULL) == 0) &&\r
  81       ((1ULL << _la) & ((1ULL << TocParser::T__1)\r
  82       | (1ULL << TocParser::T__7)\r
  83       | (1ULL << TocParser::T__13))) != 0));\r
  84     setState(105);\r
  85     match(TocParser::EOF);\r
  86    \r
  87   }\r
  88   catch (RecognitionException &e) {\r
  89     _errHandler->reportError(this, e);\r
  90     _localctx->exception = std::current_exception();\r
  91     _errHandler->recover(this, _localctx->exception);\r
  92   }\r
  93 \r
  94   return _localctx;\r
  95 }\r
  96 \r
  97 //----------------- DeclContext ------------------------------------------------------------------\r
  98 \r
  99 TocParser::DeclContext::DeclContext(ParserRuleContext *parent, size_t invokingState)\r
 100   : ParserRuleContext(parent, invokingState) {\r
 101 }\r
 102 \r
 103 TocParser::VarDeclContext* TocParser::DeclContext::varDecl() {\r
 104   return getRuleContext<TocParser::VarDeclContext>(0);\r
 105 }\r
 106 \r
 107 TocParser::FuncDeclContext* TocParser::DeclContext::funcDecl() {\r
 108   return getRuleContext<TocParser::FuncDeclContext>(0);\r
 109 }\r
 110 \r
 111 TocParser::StructDeclContext* TocParser::DeclContext::structDecl() {\r
 112   return getRuleContext<TocParser::StructDeclContext>(0);\r
 113 }\r
 114 \r
 115 \r
 116 size_t TocParser::DeclContext::getRuleIndex() const {\r
 117   return TocParser::RuleDecl;\r
 118 }\r
 119 \r
 120 \r
 121 TocParser::DeclContext* TocParser::decl() {\r
 122   DeclContext *_localctx = _tracker.createInstance<DeclContext>(_ctx, getState());\r
 123   enterRule(_localctx, 2, TocParser::RuleDecl);\r
 124 \r
 125 #if __cplusplus > 201703L\r
 126   auto onExit = finally([=, this] {\r
 127 #else\r
 128   auto onExit = finally([=] {\r
 129 #endif\r
 130     exitRule();\r
 131   });\r
 132   try {\r
 133     setState(112);\r
 134     _errHandler->sync(this);\r
 135     switch (_input->LA(1)) {\r
 136       case TocParser::T__1: {\r
 137         enterOuterAlt(_localctx, 1);\r
 138         setState(107);\r
 139         varDecl();\r
 140         setState(108);\r
 141         match(TocParser::T__0);\r
 142         break;\r
 143       }\r
 144 \r
 145       case TocParser::T__7: {\r
 146         enterOuterAlt(_localctx, 2);\r
 147         setState(110);\r
 148         funcDecl();\r
 149         break;\r
 150       }\r
 151 \r
 152       case TocParser::T__13: {\r
 153         enterOuterAlt(_localctx, 3);\r
 154         setState(111);\r
 155         structDecl();\r
 156         break;\r
 157       }\r
 158 \r
 159     default:\r
 160       throw NoViableAltException(this);\r
 161     }\r
 162    \r
 163   }\r
 164   catch (RecognitionException &e) {\r
 165     _errHandler->reportError(this, e);\r
 166     _localctx->exception = std::current_exception();\r
 167     _errHandler->recover(this, _localctx->exception);\r
 168   }\r
 169 \r
 170   return _localctx;\r
 171 }\r
 172 \r
 173 //----------------- VarDeclContext ------------------------------------------------------------------\r
 174 \r
 175 TocParser::VarDeclContext::VarDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 176   : ParserRuleContext(parent, invokingState) {\r
 177 }\r
 178 \r
 179 TocParser::VarContext* TocParser::VarDeclContext::var() {\r
 180   return getRuleContext<TocParser::VarContext>(0);\r
 181 }\r
 182 \r
 183 \r
 184 size_t TocParser::VarDeclContext::getRuleIndex() const {\r
 185   return TocParser::RuleVarDecl;\r
 186 }\r
 187 \r
 188 \r
 189 TocParser::VarDeclContext* TocParser::varDecl() {\r
 190   VarDeclContext *_localctx = _tracker.createInstance<VarDeclContext>(_ctx, getState());\r
 191   enterRule(_localctx, 4, TocParser::RuleVarDecl);\r
 192 \r
 193 #if __cplusplus > 201703L\r
 194   auto onExit = finally([=, this] {\r
 195 #else\r
 196   auto onExit = finally([=] {\r
 197 #endif\r
 198     exitRule();\r
 199   });\r
 200   try {\r
 201     enterOuterAlt(_localctx, 1);\r
 202     setState(114);\r
 203     match(TocParser::T__1);\r
 204     setState(115);\r
 205     var();\r
 206    \r
 207   }\r
 208   catch (RecognitionException &e) {\r
 209     _errHandler->reportError(this, e);\r
 210     _localctx->exception = std::current_exception();\r
 211     _errHandler->recover(this, _localctx->exception);\r
 212   }\r
 213 \r
 214   return _localctx;\r
 215 }\r
 216 \r
 217 //----------------- VarContext ------------------------------------------------------------------\r
 218 \r
 219 TocParser::VarContext::VarContext(ParserRuleContext *parent, size_t invokingState)\r
 220   : ParserRuleContext(parent, invokingState) {\r
 221 }\r
 222 \r
 223 TocParser::VarNameContext* TocParser::VarContext::varName() {\r
 224   return getRuleContext<TocParser::VarNameContext>(0);\r
 225 }\r
 226 \r
 227 TocParser::TypeContext* TocParser::VarContext::type() {\r
 228   return getRuleContext<TocParser::TypeContext>(0);\r
 229 }\r
 230 \r
 231 TocParser::ExprContext* TocParser::VarContext::expr() {\r
 232   return getRuleContext<TocParser::ExprContext>(0);\r
 233 }\r
 234 \r
 235 \r
 236 size_t TocParser::VarContext::getRuleIndex() const {\r
 237   return TocParser::RuleVar;\r
 238 }\r
 239 \r
 240 \r
 241 TocParser::VarContext* TocParser::var() {\r
 242   VarContext *_localctx = _tracker.createInstance<VarContext>(_ctx, getState());\r
 243   enterRule(_localctx, 6, TocParser::RuleVar);\r
 244   size_t _la = 0;\r
 245 \r
 246 #if __cplusplus > 201703L\r
 247   auto onExit = finally([=, this] {\r
 248 #else\r
 249   auto onExit = finally([=] {\r
 250 #endif\r
 251     exitRule();\r
 252   });\r
 253   try {\r
 254     enterOuterAlt(_localctx, 1);\r
 255     setState(117);\r
 256     varName();\r
 257 \r
 258     setState(118);\r
 259     match(TocParser::T__2);\r
 260     setState(119);\r
 261     type();\r
 262     setState(123);\r
 263     _errHandler->sync(this);\r
 264 \r
 265     _la = _input->LA(1);\r
 266     if (_la == TocParser::T__3) {\r
 267       setState(121);\r
 268       match(TocParser::T__3);\r
 269       setState(122);\r
 270       expr();\r
 271     }\r
 272    \r
 273   }\r
 274   catch (RecognitionException &e) {\r
 275     _errHandler->reportError(this, e);\r
 276     _localctx->exception = std::current_exception();\r
 277     _errHandler->recover(this, _localctx->exception);\r
 278   }\r
 279 \r
 280   return _localctx;\r
 281 }\r
 282 \r
 283 //----------------- VarInitContext ------------------------------------------------------------------\r
 284 \r
 285 TocParser::VarInitContext::VarInitContext(ParserRuleContext *parent, size_t invokingState)\r
 286   : ParserRuleContext(parent, invokingState) {\r
 287 }\r
 288 \r
 289 TocParser::VarNameContext* TocParser::VarInitContext::varName() {\r
 290   return getRuleContext<TocParser::VarNameContext>(0);\r
 291 }\r
 292 \r
 293 TocParser::TypeContext* TocParser::VarInitContext::type() {\r
 294   return getRuleContext<TocParser::TypeContext>(0);\r
 295 }\r
 296 \r
 297 TocParser::ExprContext* TocParser::VarInitContext::expr() {\r
 298   return getRuleContext<TocParser::ExprContext>(0);\r
 299 }\r
 300 \r
 301 \r
 302 size_t TocParser::VarInitContext::getRuleIndex() const {\r
 303   return TocParser::RuleVarInit;\r
 304 }\r
 305 \r
 306 \r
 307 TocParser::VarInitContext* TocParser::varInit() {\r
 308   VarInitContext *_localctx = _tracker.createInstance<VarInitContext>(_ctx, getState());\r
 309   enterRule(_localctx, 8, TocParser::RuleVarInit);\r
 310 \r
 311 #if __cplusplus > 201703L\r
 312   auto onExit = finally([=, this] {\r
 313 #else\r
 314   auto onExit = finally([=] {\r
 315 #endif\r
 316     exitRule();\r
 317   });\r
 318   try {\r
 319     enterOuterAlt(_localctx, 1);\r
 320     setState(125);\r
 321     varName();\r
 322 \r
 323     setState(126);\r
 324     match(TocParser::T__2);\r
 325     setState(127);\r
 326     type();\r
 327 \r
 328     setState(129);\r
 329     match(TocParser::T__3);\r
 330     setState(130);\r
 331     expr();\r
 332    \r
 333   }\r
 334   catch (RecognitionException &e) {\r
 335     _errHandler->reportError(this, e);\r
 336     _localctx->exception = std::current_exception();\r
 337     _errHandler->recover(this, _localctx->exception);\r
 338   }\r
 339 \r
 340   return _localctx;\r
 341 }\r
 342 \r
 343 //----------------- TypeContext ------------------------------------------------------------------\r
 344 \r
 345 TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)\r
 346   : ParserRuleContext(parent, invokingState) {\r
 347 }\r
 348 \r
 349 TocParser::TypeNameContext* TocParser::TypeContext::typeName() {\r
 350   return getRuleContext<TocParser::TypeNameContext>(0);\r
 351 }\r
 352 \r
 353 std::vector<TocParser::TypeModifierContext *> TocParser::TypeContext::typeModifier() {\r
 354   return getRuleContexts<TocParser::TypeModifierContext>();\r
 355 }\r
 356 \r
 357 TocParser::TypeModifierContext* TocParser::TypeContext::typeModifier(size_t i) {\r
 358   return getRuleContext<TocParser::TypeModifierContext>(i);\r
 359 }\r
 360 \r
 361 \r
 362 size_t TocParser::TypeContext::getRuleIndex() const {\r
 363   return TocParser::RuleType;\r
 364 }\r
 365 \r
 366 \r
 367 TocParser::TypeContext* TocParser::type() {\r
 368   TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());\r
 369   enterRule(_localctx, 10, TocParser::RuleType);\r
 370   size_t _la = 0;\r
 371 \r
 372 #if __cplusplus > 201703L\r
 373   auto onExit = finally([=, this] {\r
 374 #else\r
 375   auto onExit = finally([=] {\r
 376 #endif\r
 377     exitRule();\r
 378   });\r
 379   try {\r
 380     enterOuterAlt(_localctx, 1);\r
 381     setState(132);\r
 382     typeName();\r
 383     setState(136);\r
 384     _errHandler->sync(this);\r
 385     _la = _input->LA(1);\r
 386     while (_la == TocParser::T__4\r
 387 \r
 388     || _la == TocParser::T__5) {\r
 389       setState(133);\r
 390       typeModifier();\r
 391       setState(138);\r
 392       _errHandler->sync(this);\r
 393       _la = _input->LA(1);\r
 394     }\r
 395    \r
 396   }\r
 397   catch (RecognitionException &e) {\r
 398     _errHandler->reportError(this, e);\r
 399     _localctx->exception = std::current_exception();\r
 400     _errHandler->recover(this, _localctx->exception);\r
 401   }\r
 402 \r
 403   return _localctx;\r
 404 }\r
 405 \r
 406 //----------------- TypeModifierContext ------------------------------------------------------------------\r
 407 \r
 408 TocParser::TypeModifierContext::TypeModifierContext(ParserRuleContext *parent, size_t invokingState)\r
 409   : ParserRuleContext(parent, invokingState) {\r
 410 }\r
 411 \r
 412 tree::TerminalNode* TocParser::TypeModifierContext::INT_LIT() {\r
 413   return getToken(TocParser::INT_LIT, 0);\r
 414 }\r
 415 \r
 416 \r
 417 size_t TocParser::TypeModifierContext::getRuleIndex() const {\r
 418   return TocParser::RuleTypeModifier;\r
 419 }\r
 420 \r
 421 \r
 422 TocParser::TypeModifierContext* TocParser::typeModifier() {\r
 423   TypeModifierContext *_localctx = _tracker.createInstance<TypeModifierContext>(_ctx, getState());\r
 424   enterRule(_localctx, 12, TocParser::RuleTypeModifier);\r
 425   size_t _la = 0;\r
 426 \r
 427 #if __cplusplus > 201703L\r
 428   auto onExit = finally([=, this] {\r
 429 #else\r
 430   auto onExit = finally([=] {\r
 431 #endif\r
 432     exitRule();\r
 433   });\r
 434   try {\r
 435     setState(145);\r
 436     _errHandler->sync(this);\r
 437     switch (_input->LA(1)) {\r
 438       case TocParser::T__4: {\r
 439         enterOuterAlt(_localctx, 1);\r
 440         setState(139);\r
 441         match(TocParser::T__4);\r
 442         break;\r
 443       }\r
 444 \r
 445       case TocParser::T__5: {\r
 446         enterOuterAlt(_localctx, 2);\r
 447         setState(140);\r
 448         match(TocParser::T__5);\r
 449         setState(142);\r
 450         _errHandler->sync(this);\r
 451 \r
 452         _la = _input->LA(1);\r
 453         if (_la == TocParser::INT_LIT) {\r
 454           setState(141);\r
 455           match(TocParser::INT_LIT);\r
 456         }\r
 457         setState(144);\r
 458         match(TocParser::T__6);\r
 459         break;\r
 460       }\r
 461 \r
 462     default:\r
 463       throw NoViableAltException(this);\r
 464     }\r
 465    \r
 466   }\r
 467   catch (RecognitionException &e) {\r
 468     _errHandler->reportError(this, e);\r
 469     _localctx->exception = std::current_exception();\r
 470     _errHandler->recover(this, _localctx->exception);\r
 471   }\r
 472 \r
 473   return _localctx;\r
 474 }\r
 475 \r
 476 //----------------- FuncDeclContext ------------------------------------------------------------------\r
 477 \r
 478 TocParser::FuncDeclContext::FuncDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 479   : ParserRuleContext(parent, invokingState) {\r
 480 }\r
 481 \r
 482 TocParser::FuncContext* TocParser::FuncDeclContext::func() {\r
 483   return getRuleContext<TocParser::FuncContext>(0);\r
 484 }\r
 485 \r
 486 \r
 487 size_t TocParser::FuncDeclContext::getRuleIndex() const {\r
 488   return TocParser::RuleFuncDecl;\r
 489 }\r
 490 \r
 491 \r
 492 TocParser::FuncDeclContext* TocParser::funcDecl() {\r
 493   FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());\r
 494   enterRule(_localctx, 14, TocParser::RuleFuncDecl);\r
 495 \r
 496 #if __cplusplus > 201703L\r
 497   auto onExit = finally([=, this] {\r
 498 #else\r
 499   auto onExit = finally([=] {\r
 500 #endif\r
 501     exitRule();\r
 502   });\r
 503   try {\r
 504     enterOuterAlt(_localctx, 1);\r
 505     setState(147);\r
 506     match(TocParser::T__7);\r
 507     setState(148);\r
 508     func();\r
 509    \r
 510   }\r
 511   catch (RecognitionException &e) {\r
 512     _errHandler->reportError(this, e);\r
 513     _localctx->exception = std::current_exception();\r
 514     _errHandler->recover(this, _localctx->exception);\r
 515   }\r
 516 \r
 517   return _localctx;\r
 518 }\r
 519 \r
 520 //----------------- FuncContext ------------------------------------------------------------------\r
 521 \r
 522 TocParser::FuncContext::FuncContext(ParserRuleContext *parent, size_t invokingState)\r
 523   : ParserRuleContext(parent, invokingState) {\r
 524 }\r
 525 \r
 526 TocParser::FuncNameContext* TocParser::FuncContext::funcName() {\r
 527   return getRuleContext<TocParser::FuncNameContext>(0);\r
 528 }\r
 529 \r
 530 TocParser::ParameterContext* TocParser::FuncContext::parameter() {\r
 531   return getRuleContext<TocParser::ParameterContext>(0);\r
 532 }\r
 533 \r
 534 TocParser::BodyContext* TocParser::FuncContext::body() {\r
 535   return getRuleContext<TocParser::BodyContext>(0);\r
 536 }\r
 537 \r
 538 TocParser::TypeContext* TocParser::FuncContext::type() {\r
 539   return getRuleContext<TocParser::TypeContext>(0);\r
 540 }\r
 541 \r
 542 TocParser::GenericDeclContext* TocParser::FuncContext::genericDecl() {\r
 543   return getRuleContext<TocParser::GenericDeclContext>(0);\r
 544 }\r
 545 \r
 546 \r
 547 size_t TocParser::FuncContext::getRuleIndex() const {\r
 548   return TocParser::RuleFunc;\r
 549 }\r
 550 \r
 551 \r
 552 TocParser::FuncContext* TocParser::func() {\r
 553   FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());\r
 554   enterRule(_localctx, 16, TocParser::RuleFunc);\r
 555   size_t _la = 0;\r
 556 \r
 557 #if __cplusplus > 201703L\r
 558   auto onExit = finally([=, this] {\r
 559 #else\r
 560   auto onExit = finally([=] {\r
 561 #endif\r
 562     exitRule();\r
 563   });\r
 564   try {\r
 565     enterOuterAlt(_localctx, 1);\r
 566     setState(150);\r
 567     funcName();\r
 568     setState(152);\r
 569     _errHandler->sync(this);\r
 570 \r
 571     _la = _input->LA(1);\r
 572     if (_la == TocParser::T__14) {\r
 573       setState(151);\r
 574       genericDecl();\r
 575     }\r
 576     setState(154);\r
 577     match(TocParser::T__8);\r
 578     setState(155);\r
 579     parameter();\r
 580     setState(156);\r
 581     match(TocParser::T__9);\r
 582 \r
 583     setState(157);\r
 584     match(TocParser::T__2);\r
 585     setState(158);\r
 586     type();\r
 587     setState(160);\r
 588     body();\r
 589    \r
 590   }\r
 591   catch (RecognitionException &e) {\r
 592     _errHandler->reportError(this, e);\r
 593     _localctx->exception = std::current_exception();\r
 594     _errHandler->recover(this, _localctx->exception);\r
 595   }\r
 596 \r
 597   return _localctx;\r
 598 }\r
 599 \r
 600 //----------------- ParameterContext ------------------------------------------------------------------\r
 601 \r
 602 TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t invokingState)\r
 603   : ParserRuleContext(parent, invokingState) {\r
 604 }\r
 605 \r
 606 std::vector<TocParser::VarContext *> TocParser::ParameterContext::var() {\r
 607   return getRuleContexts<TocParser::VarContext>();\r
 608 }\r
 609 \r
 610 TocParser::VarContext* TocParser::ParameterContext::var(size_t i) {\r
 611   return getRuleContext<TocParser::VarContext>(i);\r
 612 }\r
 613 \r
 614 \r
 615 size_t TocParser::ParameterContext::getRuleIndex() const {\r
 616   return TocParser::RuleParameter;\r
 617 }\r
 618 \r
 619 \r
 620 TocParser::ParameterContext* TocParser::parameter() {\r
 621   ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());\r
 622   enterRule(_localctx, 18, TocParser::RuleParameter);\r
 623   size_t _la = 0;\r
 624 \r
 625 #if __cplusplus > 201703L\r
 626   auto onExit = finally([=, this] {\r
 627 #else\r
 628   auto onExit = finally([=] {\r
 629 #endif\r
 630     exitRule();\r
 631   });\r
 632   try {\r
 633     enterOuterAlt(_localctx, 1);\r
 634     setState(170);\r
 635     _errHandler->sync(this);\r
 636 \r
 637     _la = _input->LA(1);\r
 638     if (_la == TocParser::NAME) {\r
 639       setState(162);\r
 640       var();\r
 641       setState(167);\r
 642       _errHandler->sync(this);\r
 643       _la = _input->LA(1);\r
 644       while (_la == TocParser::T__10) {\r
 645         setState(163);\r
 646         match(TocParser::T__10);\r
 647         setState(164);\r
 648         var();\r
 649         setState(169);\r
 650         _errHandler->sync(this);\r
 651         _la = _input->LA(1);\r
 652       }\r
 653     }\r
 654    \r
 655   }\r
 656   catch (RecognitionException &e) {\r
 657     _errHandler->reportError(this, e);\r
 658     _localctx->exception = std::current_exception();\r
 659     _errHandler->recover(this, _localctx->exception);\r
 660   }\r
 661 \r
 662   return _localctx;\r
 663 }\r
 664 \r
 665 //----------------- BodyContext ------------------------------------------------------------------\r
 666 \r
 667 TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState)\r
 668   : ParserRuleContext(parent, invokingState) {\r
 669 }\r
 670 \r
 671 std::vector<TocParser::StmtContext *> TocParser::BodyContext::stmt() {\r
 672   return getRuleContexts<TocParser::StmtContext>();\r
 673 }\r
 674 \r
 675 TocParser::StmtContext* TocParser::BodyContext::stmt(size_t i) {\r
 676   return getRuleContext<TocParser::StmtContext>(i);\r
 677 }\r
 678 \r
 679 \r
 680 size_t TocParser::BodyContext::getRuleIndex() const {\r
 681   return TocParser::RuleBody;\r
 682 }\r
 683 \r
 684 \r
 685 TocParser::BodyContext* TocParser::body() {\r
 686   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());\r
 687   enterRule(_localctx, 20, TocParser::RuleBody);\r
 688   size_t _la = 0;\r
 689 \r
 690 #if __cplusplus > 201703L\r
 691   auto onExit = finally([=, this] {\r
 692 #else\r
 693   auto onExit = finally([=] {\r
 694 #endif\r
 695     exitRule();\r
 696   });\r
 697   try {\r
 698     enterOuterAlt(_localctx, 1);\r
 699     setState(172);\r
 700     match(TocParser::T__11);\r
 701     setState(176);\r
 702     _errHandler->sync(this);\r
 703     _la = _input->LA(1);\r
 704     while ((((_la & ~ 0x3fULL) == 0) &&\r
 705       ((1ULL << _la) & ((1ULL << TocParser::T__1)\r
 706       | (1ULL << TocParser::T__4)\r
 707       | (1ULL << TocParser::T__8)\r
 708       | (1ULL << TocParser::T__16)\r
 709       | (1ULL << TocParser::T__18)\r
 710       | (1ULL << TocParser::T__20)\r
 711       | (1ULL << TocParser::T__21)\r
 712       | (1ULL << TocParser::T__22)\r
 713       | (1ULL << TocParser::T__26)\r
 714       | (1ULL << TocParser::T__27)\r
 715       | (1ULL << TocParser::T__28)\r
 716       | (1ULL << TocParser::T__29)\r
 717       | (1ULL << TocParser::T__30)\r
 718       | (1ULL << TocParser::T__31)\r
 719       | (1ULL << TocParser::T__32)\r
 720       | (1ULL << TocParser::INT_LIT)\r
 721       | (1ULL << TocParser::DECIMAL_LIT)\r
 722       | (1ULL << TocParser::STRING_LIT)\r
 723       | (1ULL << TocParser::BOOL_LIT)\r
 724       | (1ULL << TocParser::NAME))) != 0)) {\r
 725       setState(173);\r
 726       stmt();\r
 727       setState(178);\r
 728       _errHandler->sync(this);\r
 729       _la = _input->LA(1);\r
 730     }\r
 731     setState(179);\r
 732     match(TocParser::T__12);\r
 733    \r
 734   }\r
 735   catch (RecognitionException &e) {\r
 736     _errHandler->reportError(this, e);\r
 737     _localctx->exception = std::current_exception();\r
 738     _errHandler->recover(this, _localctx->exception);\r
 739   }\r
 740 \r
 741   return _localctx;\r
 742 }\r
 743 \r
 744 //----------------- StructDeclContext ------------------------------------------------------------------\r
 745 \r
 746 TocParser::StructDeclContext::StructDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 747   : ParserRuleContext(parent, invokingState) {\r
 748 }\r
 749 \r
 750 TocParser::StructNameContext* TocParser::StructDeclContext::structName() {\r
 751   return getRuleContext<TocParser::StructNameContext>(0);\r
 752 }\r
 753 \r
 754 TocParser::GenericDeclContext* TocParser::StructDeclContext::genericDecl() {\r
 755   return getRuleContext<TocParser::GenericDeclContext>(0);\r
 756 }\r
 757 \r
 758 std::vector<TocParser::StructMemberContext *> TocParser::StructDeclContext::structMember() {\r
 759   return getRuleContexts<TocParser::StructMemberContext>();\r
 760 }\r
 761 \r
 762 TocParser::StructMemberContext* TocParser::StructDeclContext::structMember(size_t i) {\r
 763   return getRuleContext<TocParser::StructMemberContext>(i);\r
 764 }\r
 765 \r
 766 \r
 767 size_t TocParser::StructDeclContext::getRuleIndex() const {\r
 768   return TocParser::RuleStructDecl;\r
 769 }\r
 770 \r
 771 \r
 772 TocParser::StructDeclContext* TocParser::structDecl() {\r
 773   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());\r
 774   enterRule(_localctx, 22, TocParser::RuleStructDecl);\r
 775   size_t _la = 0;\r
 776 \r
 777 #if __cplusplus > 201703L\r
 778   auto onExit = finally([=, this] {\r
 779 #else\r
 780   auto onExit = finally([=] {\r
 781 #endif\r
 782     exitRule();\r
 783   });\r
 784   try {\r
 785     enterOuterAlt(_localctx, 1);\r
 786     setState(181);\r
 787     match(TocParser::T__13);\r
 788     setState(182);\r
 789     structName();\r
 790     setState(184);\r
 791     _errHandler->sync(this);\r
 792 \r
 793     _la = _input->LA(1);\r
 794     if (_la == TocParser::T__14) {\r
 795       setState(183);\r
 796       genericDecl();\r
 797     }\r
 798     setState(186);\r
 799     match(TocParser::T__11);\r
 800     setState(190);\r
 801     _errHandler->sync(this);\r
 802     _la = _input->LA(1);\r
 803     while (_la == TocParser::NAME) {\r
 804       setState(187);\r
 805       structMember();\r
 806       setState(192);\r
 807       _errHandler->sync(this);\r
 808       _la = _input->LA(1);\r
 809     }\r
 810     setState(193);\r
 811     match(TocParser::T__12);\r
 812    \r
 813   }\r
 814   catch (RecognitionException &e) {\r
 815     _errHandler->reportError(this, e);\r
 816     _localctx->exception = std::current_exception();\r
 817     _errHandler->recover(this, _localctx->exception);\r
 818   }\r
 819 \r
 820   return _localctx;\r
 821 }\r
 822 \r
 823 //----------------- StructMemberContext ------------------------------------------------------------------\r
 824 \r
 825 TocParser::StructMemberContext::StructMemberContext(ParserRuleContext *parent, size_t invokingState)\r
 826   : ParserRuleContext(parent, invokingState) {\r
 827 }\r
 828 \r
 829 TocParser::StructVarContext* TocParser::StructMemberContext::structVar() {\r
 830   return getRuleContext<TocParser::StructVarContext>(0);\r
 831 }\r
 832 \r
 833 TocParser::StructMethodContext* TocParser::StructMemberContext::structMethod() {\r
 834   return getRuleContext<TocParser::StructMethodContext>(0);\r
 835 }\r
 836 \r
 837 \r
 838 size_t TocParser::StructMemberContext::getRuleIndex() const {\r
 839   return TocParser::RuleStructMember;\r
 840 }\r
 841 \r
 842 \r
 843 TocParser::StructMemberContext* TocParser::structMember() {\r
 844   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());\r
 845   enterRule(_localctx, 24, TocParser::RuleStructMember);\r
 846 \r
 847 #if __cplusplus > 201703L\r
 848   auto onExit = finally([=, this] {\r
 849 #else\r
 850   auto onExit = finally([=] {\r
 851 #endif\r
 852     exitRule();\r
 853   });\r
 854   try {\r
 855     setState(197);\r
 856     _errHandler->sync(this);\r
 857     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {\r
 858     case 1: {\r
 859       enterOuterAlt(_localctx, 1);\r
 860       setState(195);\r
 861       structVar();\r
 862       break;\r
 863     }\r
 864 \r
 865     case 2: {\r
 866       enterOuterAlt(_localctx, 2);\r
 867       setState(196);\r
 868       structMethod();\r
 869       break;\r
 870     }\r
 871 \r
 872     default:\r
 873       break;\r
 874     }\r
 875    \r
 876   }\r
 877   catch (RecognitionException &e) {\r
 878     _errHandler->reportError(this, e);\r
 879     _localctx->exception = std::current_exception();\r
 880     _errHandler->recover(this, _localctx->exception);\r
 881   }\r
 882 \r
 883   return _localctx;\r
 884 }\r
 885 \r
 886 //----------------- StructVarContext ------------------------------------------------------------------\r
 887 \r
 888 TocParser::StructVarContext::StructVarContext(ParserRuleContext *parent, size_t invokingState)\r
 889   : ParserRuleContext(parent, invokingState) {\r
 890 }\r
 891 \r
 892 TocParser::VarContext* TocParser::StructVarContext::var() {\r
 893   return getRuleContext<TocParser::VarContext>(0);\r
 894 }\r
 895 \r
 896 \r
 897 size_t TocParser::StructVarContext::getRuleIndex() const {\r
 898   return TocParser::RuleStructVar;\r
 899 }\r
 900 \r
 901 \r
 902 TocParser::StructVarContext* TocParser::structVar() {\r
 903   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());\r
 904   enterRule(_localctx, 26, TocParser::RuleStructVar);\r
 905 \r
 906 #if __cplusplus > 201703L\r
 907   auto onExit = finally([=, this] {\r
 908 #else\r
 909   auto onExit = finally([=] {\r
 910 #endif\r
 911     exitRule();\r
 912   });\r
 913   try {\r
 914     enterOuterAlt(_localctx, 1);\r
 915     setState(199);\r
 916     var();\r
 917     setState(200);\r
 918     match(TocParser::T__0);\r
 919    \r
 920   }\r
 921   catch (RecognitionException &e) {\r
 922     _errHandler->reportError(this, e);\r
 923     _localctx->exception = std::current_exception();\r
 924     _errHandler->recover(this, _localctx->exception);\r
 925   }\r
 926 \r
 927   return _localctx;\r
 928 }\r
 929 \r
 930 //----------------- StructMethodContext ------------------------------------------------------------------\r
 931 \r
 932 TocParser::StructMethodContext::StructMethodContext(ParserRuleContext *parent, size_t invokingState)\r
 933   : ParserRuleContext(parent, invokingState) {\r
 934 }\r
 935 \r
 936 TocParser::FuncContext* TocParser::StructMethodContext::func() {\r
 937   return getRuleContext<TocParser::FuncContext>(0);\r
 938 }\r
 939 \r
 940 \r
 941 size_t TocParser::StructMethodContext::getRuleIndex() const {\r
 942   return TocParser::RuleStructMethod;\r
 943 }\r
 944 \r
 945 \r
 946 TocParser::StructMethodContext* TocParser::structMethod() {\r
 947   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());\r
 948   enterRule(_localctx, 28, TocParser::RuleStructMethod);\r
 949 \r
 950 #if __cplusplus > 201703L\r
 951   auto onExit = finally([=, this] {\r
 952 #else\r
 953   auto onExit = finally([=] {\r
 954 #endif\r
 955     exitRule();\r
 956   });\r
 957   try {\r
 958     enterOuterAlt(_localctx, 1);\r
 959     setState(202);\r
 960     func();\r
 961    \r
 962   }\r
 963   catch (RecognitionException &e) {\r
 964     _errHandler->reportError(this, e);\r
 965     _localctx->exception = std::current_exception();\r
 966     _errHandler->recover(this, _localctx->exception);\r
 967   }\r
 968 \r
 969   return _localctx;\r
 970 }\r
 971 \r
 972 //----------------- GenericDeclContext ------------------------------------------------------------------\r
 973 \r
 974 TocParser::GenericDeclContext::GenericDeclContext(ParserRuleContext *parent, size_t invokingState)\r
 975   : ParserRuleContext(parent, invokingState) {\r
 976 }\r
 977 \r
 978 std::vector<TocParser::TypeNameContext *> TocParser::GenericDeclContext::typeName() {\r
 979   return getRuleContexts<TocParser::TypeNameContext>();\r
 980 }\r
 981 \r
 982 TocParser::TypeNameContext* TocParser::GenericDeclContext::typeName(size_t i) {\r
 983   return getRuleContext<TocParser::TypeNameContext>(i);\r
 984 }\r
 985 \r
 986 \r
 987 size_t TocParser::GenericDeclContext::getRuleIndex() const {\r
 988   return TocParser::RuleGenericDecl;\r
 989 }\r
 990 \r
 991 \r
 992 TocParser::GenericDeclContext* TocParser::genericDecl() {\r
 993   GenericDeclContext *_localctx = _tracker.createInstance<GenericDeclContext>(_ctx, getState());\r
 994   enterRule(_localctx, 30, TocParser::RuleGenericDecl);\r
 995   size_t _la = 0;\r
 996 \r
 997 #if __cplusplus > 201703L\r
 998   auto onExit = finally([=, this] {\r
 999 #else\r
1000   auto onExit = finally([=] {\r
1001 #endif\r
1002     exitRule();\r
1003   });\r
1004   try {\r
1005     enterOuterAlt(_localctx, 1);\r
1006     setState(204);\r
1007     match(TocParser::T__14);\r
1008     setState(205);\r
1009     typeName();\r
1010     setState(210);\r
1011     _errHandler->sync(this);\r
1012     _la = _input->LA(1);\r
1013     while (_la == TocParser::T__10) {\r
1014       setState(206);\r
1015       match(TocParser::T__10);\r
1016       setState(207);\r
1017       typeName();\r
1018       setState(212);\r
1019       _errHandler->sync(this);\r
1020       _la = _input->LA(1);\r
1021     }\r
1022     setState(213);\r
1023     match(TocParser::T__15);\r
1024    \r
1025   }\r
1026   catch (RecognitionException &e) {\r
1027     _errHandler->reportError(this, e);\r
1028     _localctx->exception = std::current_exception();\r
1029     _errHandler->recover(this, _localctx->exception);\r
1030   }\r
1031 \r
1032   return _localctx;\r
1033 }\r
1034 \r
1035 //----------------- StmtContext ------------------------------------------------------------------\r
1036 \r
1037 TocParser::StmtContext::StmtContext(ParserRuleContext *parent, size_t invokingState)\r
1038   : ParserRuleContext(parent, invokingState) {\r
1039 }\r
1040 \r
1041 TocParser::VarDeclContext* TocParser::StmtContext::varDecl() {\r
1042   return getRuleContext<TocParser::VarDeclContext>(0);\r
1043 }\r
1044 \r
1045 TocParser::IfStmtContext* TocParser::StmtContext::ifStmt() {\r
1046   return getRuleContext<TocParser::IfStmtContext>(0);\r
1047 }\r
1048 \r
1049 TocParser::SwitchStmtContext* TocParser::StmtContext::switchStmt() {\r
1050   return getRuleContext<TocParser::SwitchStmtContext>(0);\r
1051 }\r
1052 \r
1053 TocParser::ForStmtContext* TocParser::StmtContext::forStmt() {\r
1054   return getRuleContext<TocParser::ForStmtContext>(0);\r
1055 }\r
1056 \r
1057 TocParser::WhileStmtContext* TocParser::StmtContext::whileStmt() {\r
1058   return getRuleContext<TocParser::WhileStmtContext>(0);\r
1059 }\r
1060 \r
1061 TocParser::AssignStmtContext* TocParser::StmtContext::assignStmt() {\r
1062   return getRuleContext<TocParser::AssignStmtContext>(0);\r
1063 }\r
1064 \r
1065 TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {\r
1066   return getRuleContext<TocParser::ReturnStmtContext>(0);\r
1067 }\r
1068 \r
1069 TocParser::ExprContext* TocParser::StmtContext::expr() {\r
1070   return getRuleContext<TocParser::ExprContext>(0);\r
1071 }\r
1072 \r
1073 \r
1074 size_t TocParser::StmtContext::getRuleIndex() const {\r
1075   return TocParser::RuleStmt;\r
1076 }\r
1077 \r
1078 \r
1079 TocParser::StmtContext* TocParser::stmt() {\r
1080   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());\r
1081   enterRule(_localctx, 32, TocParser::RuleStmt);\r
1082 \r
1083 #if __cplusplus > 201703L\r
1084   auto onExit = finally([=, this] {\r
1085 #else\r
1086   auto onExit = finally([=] {\r
1087 #endif\r
1088     exitRule();\r
1089   });\r
1090   try {\r
1091     setState(231);\r
1092     _errHandler->sync(this);\r
1093     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 14, _ctx)) {\r
1094     case 1: {\r
1095       enterOuterAlt(_localctx, 1);\r
1096       setState(215);\r
1097       varDecl();\r
1098       setState(216);\r
1099       match(TocParser::T__0);\r
1100       break;\r
1101     }\r
1102 \r
1103     case 2: {\r
1104       enterOuterAlt(_localctx, 2);\r
1105       setState(218);\r
1106       ifStmt();\r
1107       break;\r
1108     }\r
1109 \r
1110     case 3: {\r
1111       enterOuterAlt(_localctx, 3);\r
1112       setState(219);\r
1113       switchStmt();\r
1114       break;\r
1115     }\r
1116 \r
1117     case 4: {\r
1118       enterOuterAlt(_localctx, 4);\r
1119       setState(220);\r
1120       forStmt();\r
1121       break;\r
1122     }\r
1123 \r
1124     case 5: {\r
1125       enterOuterAlt(_localctx, 5);\r
1126       setState(221);\r
1127       whileStmt();\r
1128       break;\r
1129     }\r
1130 \r
1131     case 6: {\r
1132       enterOuterAlt(_localctx, 6);\r
1133       setState(222);\r
1134       assignStmt();\r
1135       setState(223);\r
1136       match(TocParser::T__0);\r
1137       break;\r
1138     }\r
1139 \r
1140     case 7: {\r
1141       enterOuterAlt(_localctx, 7);\r
1142       setState(225);\r
1143       returnStmt();\r
1144       setState(226);\r
1145       match(TocParser::T__0);\r
1146       break;\r
1147     }\r
1148 \r
1149     case 8: {\r
1150       enterOuterAlt(_localctx, 8);\r
1151       setState(228);\r
1152       expr();\r
1153       setState(229);\r
1154       match(TocParser::T__0);\r
1155       break;\r
1156     }\r
1157 \r
1158     default:\r
1159       break;\r
1160     }\r
1161    \r
1162   }\r
1163   catch (RecognitionException &e) {\r
1164     _errHandler->reportError(this, e);\r
1165     _localctx->exception = std::current_exception();\r
1166     _errHandler->recover(this, _localctx->exception);\r
1167   }\r
1168 \r
1169   return _localctx;\r
1170 }\r
1171 \r
1172 //----------------- IfStmtContext ------------------------------------------------------------------\r
1173 \r
1174 TocParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1175   : ParserRuleContext(parent, invokingState) {\r
1176 }\r
1177 \r
1178 TocParser::ExprContext* TocParser::IfStmtContext::expr() {\r
1179   return getRuleContext<TocParser::ExprContext>(0);\r
1180 }\r
1181 \r
1182 TocParser::BodyContext* TocParser::IfStmtContext::body() {\r
1183   return getRuleContext<TocParser::BodyContext>(0);\r
1184 }\r
1185 \r
1186 std::vector<TocParser::ElseIfStmtContext *> TocParser::IfStmtContext::elseIfStmt() {\r
1187   return getRuleContexts<TocParser::ElseIfStmtContext>();\r
1188 }\r
1189 \r
1190 TocParser::ElseIfStmtContext* TocParser::IfStmtContext::elseIfStmt(size_t i) {\r
1191   return getRuleContext<TocParser::ElseIfStmtContext>(i);\r
1192 }\r
1193 \r
1194 TocParser::ElseStmtContext* TocParser::IfStmtContext::elseStmt() {\r
1195   return getRuleContext<TocParser::ElseStmtContext>(0);\r
1196 }\r
1197 \r
1198 \r
1199 size_t TocParser::IfStmtContext::getRuleIndex() const {\r
1200   return TocParser::RuleIfStmt;\r
1201 }\r
1202 \r
1203 \r
1204 TocParser::IfStmtContext* TocParser::ifStmt() {\r
1205   IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());\r
1206   enterRule(_localctx, 34, TocParser::RuleIfStmt);\r
1207   size_t _la = 0;\r
1208 \r
1209 #if __cplusplus > 201703L\r
1210   auto onExit = finally([=, this] {\r
1211 #else\r
1212   auto onExit = finally([=] {\r
1213 #endif\r
1214     exitRule();\r
1215   });\r
1216   try {\r
1217     size_t alt;\r
1218     enterOuterAlt(_localctx, 1);\r
1219     setState(233);\r
1220     match(TocParser::T__16);\r
1221     setState(234);\r
1222     expr();\r
1223     setState(235);\r
1224     body();\r
1225     setState(239);\r
1226     _errHandler->sync(this);\r
1227     alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx);\r
1228     while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {\r
1229       if (alt == 1) {\r
1230         setState(236);\r
1231         elseIfStmt(); \r
1232       }\r
1233       setState(241);\r
1234       _errHandler->sync(this);\r
1235       alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx);\r
1236     }\r
1237     setState(243);\r
1238     _errHandler->sync(this);\r
1239 \r
1240     _la = _input->LA(1);\r
1241     if (_la == TocParser::T__17) {\r
1242       setState(242);\r
1243       elseStmt();\r
1244     }\r
1245    \r
1246   }\r
1247   catch (RecognitionException &e) {\r
1248     _errHandler->reportError(this, e);\r
1249     _localctx->exception = std::current_exception();\r
1250     _errHandler->recover(this, _localctx->exception);\r
1251   }\r
1252 \r
1253   return _localctx;\r
1254 }\r
1255 \r
1256 //----------------- ElseIfStmtContext ------------------------------------------------------------------\r
1257 \r
1258 TocParser::ElseIfStmtContext::ElseIfStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1259   : ParserRuleContext(parent, invokingState) {\r
1260 }\r
1261 \r
1262 TocParser::ExprContext* TocParser::ElseIfStmtContext::expr() {\r
1263   return getRuleContext<TocParser::ExprContext>(0);\r
1264 }\r
1265 \r
1266 TocParser::BodyContext* TocParser::ElseIfStmtContext::body() {\r
1267   return getRuleContext<TocParser::BodyContext>(0);\r
1268 }\r
1269 \r
1270 \r
1271 size_t TocParser::ElseIfStmtContext::getRuleIndex() const {\r
1272   return TocParser::RuleElseIfStmt;\r
1273 }\r
1274 \r
1275 \r
1276 TocParser::ElseIfStmtContext* TocParser::elseIfStmt() {\r
1277   ElseIfStmtContext *_localctx = _tracker.createInstance<ElseIfStmtContext>(_ctx, getState());\r
1278   enterRule(_localctx, 36, TocParser::RuleElseIfStmt);\r
1279 \r
1280 #if __cplusplus > 201703L\r
1281   auto onExit = finally([=, this] {\r
1282 #else\r
1283   auto onExit = finally([=] {\r
1284 #endif\r
1285     exitRule();\r
1286   });\r
1287   try {\r
1288     enterOuterAlt(_localctx, 1);\r
1289     setState(245);\r
1290     match(TocParser::T__17);\r
1291     setState(246);\r
1292     match(TocParser::T__16);\r
1293     setState(247);\r
1294     expr();\r
1295     setState(248);\r
1296     body();\r
1297    \r
1298   }\r
1299   catch (RecognitionException &e) {\r
1300     _errHandler->reportError(this, e);\r
1301     _localctx->exception = std::current_exception();\r
1302     _errHandler->recover(this, _localctx->exception);\r
1303   }\r
1304 \r
1305   return _localctx;\r
1306 }\r
1307 \r
1308 //----------------- ElseStmtContext ------------------------------------------------------------------\r
1309 \r
1310 TocParser::ElseStmtContext::ElseStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1311   : ParserRuleContext(parent, invokingState) {\r
1312 }\r
1313 \r
1314 TocParser::BodyContext* TocParser::ElseStmtContext::body() {\r
1315   return getRuleContext<TocParser::BodyContext>(0);\r
1316 }\r
1317 \r
1318 \r
1319 size_t TocParser::ElseStmtContext::getRuleIndex() const {\r
1320   return TocParser::RuleElseStmt;\r
1321 }\r
1322 \r
1323 \r
1324 TocParser::ElseStmtContext* TocParser::elseStmt() {\r
1325   ElseStmtContext *_localctx = _tracker.createInstance<ElseStmtContext>(_ctx, getState());\r
1326   enterRule(_localctx, 38, TocParser::RuleElseStmt);\r
1327 \r
1328 #if __cplusplus > 201703L\r
1329   auto onExit = finally([=, this] {\r
1330 #else\r
1331   auto onExit = finally([=] {\r
1332 #endif\r
1333     exitRule();\r
1334   });\r
1335   try {\r
1336     enterOuterAlt(_localctx, 1);\r
1337     setState(250);\r
1338     match(TocParser::T__17);\r
1339     setState(251);\r
1340     body();\r
1341    \r
1342   }\r
1343   catch (RecognitionException &e) {\r
1344     _errHandler->reportError(this, e);\r
1345     _localctx->exception = std::current_exception();\r
1346     _errHandler->recover(this, _localctx->exception);\r
1347   }\r
1348 \r
1349   return _localctx;\r
1350 }\r
1351 \r
1352 //----------------- SwitchStmtContext ------------------------------------------------------------------\r
1353 \r
1354 TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1355   : ParserRuleContext(parent, invokingState) {\r
1356 }\r
1357 \r
1358 TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() {\r
1359   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1360 }\r
1361 \r
1362 TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() {\r
1363   return getRuleContext<TocParser::SwitchBodyContext>(0);\r
1364 }\r
1365 \r
1366 \r
1367 size_t TocParser::SwitchStmtContext::getRuleIndex() const {\r
1368   return TocParser::RuleSwitchStmt;\r
1369 }\r
1370 \r
1371 \r
1372 TocParser::SwitchStmtContext* TocParser::switchStmt() {\r
1373   SwitchStmtContext *_localctx = _tracker.createInstance<SwitchStmtContext>(_ctx, getState());\r
1374   enterRule(_localctx, 40, TocParser::RuleSwitchStmt);\r
1375 \r
1376 #if __cplusplus > 201703L\r
1377   auto onExit = finally([=, this] {\r
1378 #else\r
1379   auto onExit = finally([=] {\r
1380 #endif\r
1381     exitRule();\r
1382   });\r
1383   try {\r
1384     enterOuterAlt(_localctx, 1);\r
1385     setState(253);\r
1386     match(TocParser::T__18);\r
1387     setState(254);\r
1388     identifierExpr();\r
1389     setState(255);\r
1390     switchBody();\r
1391    \r
1392   }\r
1393   catch (RecognitionException &e) {\r
1394     _errHandler->reportError(this, e);\r
1395     _localctx->exception = std::current_exception();\r
1396     _errHandler->recover(this, _localctx->exception);\r
1397   }\r
1398 \r
1399   return _localctx;\r
1400 }\r
1401 \r
1402 //----------------- SwitchBodyContext ------------------------------------------------------------------\r
1403 \r
1404 TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState)\r
1405   : ParserRuleContext(parent, invokingState) {\r
1406 }\r
1407 \r
1408 std::vector<TocParser::SwitchCaseContext *> TocParser::SwitchBodyContext::switchCase() {\r
1409   return getRuleContexts<TocParser::SwitchCaseContext>();\r
1410 }\r
1411 \r
1412 TocParser::SwitchCaseContext* TocParser::SwitchBodyContext::switchCase(size_t i) {\r
1413   return getRuleContext<TocParser::SwitchCaseContext>(i);\r
1414 }\r
1415 \r
1416 \r
1417 size_t TocParser::SwitchBodyContext::getRuleIndex() const {\r
1418   return TocParser::RuleSwitchBody;\r
1419 }\r
1420 \r
1421 \r
1422 TocParser::SwitchBodyContext* TocParser::switchBody() {\r
1423   SwitchBodyContext *_localctx = _tracker.createInstance<SwitchBodyContext>(_ctx, getState());\r
1424   enterRule(_localctx, 42, TocParser::RuleSwitchBody);\r
1425   size_t _la = 0;\r
1426 \r
1427 #if __cplusplus > 201703L\r
1428   auto onExit = finally([=, this] {\r
1429 #else\r
1430   auto onExit = finally([=] {\r
1431 #endif\r
1432     exitRule();\r
1433   });\r
1434   try {\r
1435     enterOuterAlt(_localctx, 1);\r
1436     setState(257);\r
1437     match(TocParser::T__11);\r
1438     setState(261);\r
1439     _errHandler->sync(this);\r
1440     _la = _input->LA(1);\r
1441     while (_la == TocParser::T__19) {\r
1442       setState(258);\r
1443       switchCase();\r
1444       setState(263);\r
1445       _errHandler->sync(this);\r
1446       _la = _input->LA(1);\r
1447     }\r
1448     setState(264);\r
1449     match(TocParser::T__12);\r
1450    \r
1451   }\r
1452   catch (RecognitionException &e) {\r
1453     _errHandler->reportError(this, e);\r
1454     _localctx->exception = std::current_exception();\r
1455     _errHandler->recover(this, _localctx->exception);\r
1456   }\r
1457 \r
1458   return _localctx;\r
1459 }\r
1460 \r
1461 //----------------- SwitchCaseContext ------------------------------------------------------------------\r
1462 \r
1463 TocParser::SwitchCaseContext::SwitchCaseContext(ParserRuleContext *parent, size_t invokingState)\r
1464   : ParserRuleContext(parent, invokingState) {\r
1465 }\r
1466 \r
1467 TocParser::ExprContext* TocParser::SwitchCaseContext::expr() {\r
1468   return getRuleContext<TocParser::ExprContext>(0);\r
1469 }\r
1470 \r
1471 TocParser::BodyContext* TocParser::SwitchCaseContext::body() {\r
1472   return getRuleContext<TocParser::BodyContext>(0);\r
1473 }\r
1474 \r
1475 \r
1476 size_t TocParser::SwitchCaseContext::getRuleIndex() const {\r
1477   return TocParser::RuleSwitchCase;\r
1478 }\r
1479 \r
1480 \r
1481 TocParser::SwitchCaseContext* TocParser::switchCase() {\r
1482   SwitchCaseContext *_localctx = _tracker.createInstance<SwitchCaseContext>(_ctx, getState());\r
1483   enterRule(_localctx, 44, TocParser::RuleSwitchCase);\r
1484 \r
1485 #if __cplusplus > 201703L\r
1486   auto onExit = finally([=, this] {\r
1487 #else\r
1488   auto onExit = finally([=] {\r
1489 #endif\r
1490     exitRule();\r
1491   });\r
1492   try {\r
1493     enterOuterAlt(_localctx, 1);\r
1494     setState(266);\r
1495     match(TocParser::T__19);\r
1496     setState(267);\r
1497     expr();\r
1498     setState(268);\r
1499     body();\r
1500    \r
1501   }\r
1502   catch (RecognitionException &e) {\r
1503     _errHandler->reportError(this, e);\r
1504     _localctx->exception = std::current_exception();\r
1505     _errHandler->recover(this, _localctx->exception);\r
1506   }\r
1507 \r
1508   return _localctx;\r
1509 }\r
1510 \r
1511 //----------------- ForStmtContext ------------------------------------------------------------------\r
1512 \r
1513 TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1514   : ParserRuleContext(parent, invokingState) {\r
1515 }\r
1516 \r
1517 std::vector<TocParser::ExprContext *> TocParser::ForStmtContext::expr() {\r
1518   return getRuleContexts<TocParser::ExprContext>();\r
1519 }\r
1520 \r
1521 TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) {\r
1522   return getRuleContext<TocParser::ExprContext>(i);\r
1523 }\r
1524 \r
1525 TocParser::BodyContext* TocParser::ForStmtContext::body() {\r
1526   return getRuleContext<TocParser::BodyContext>(0);\r
1527 }\r
1528 \r
1529 TocParser::VarInitContext* TocParser::ForStmtContext::varInit() {\r
1530   return getRuleContext<TocParser::VarInitContext>(0);\r
1531 }\r
1532 \r
1533 TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() {\r
1534   return getRuleContext<TocParser::AssignStmtContext>(0);\r
1535 }\r
1536 \r
1537 \r
1538 size_t TocParser::ForStmtContext::getRuleIndex() const {\r
1539   return TocParser::RuleForStmt;\r
1540 }\r
1541 \r
1542 \r
1543 TocParser::ForStmtContext* TocParser::forStmt() {\r
1544   ForStmtContext *_localctx = _tracker.createInstance<ForStmtContext>(_ctx, getState());\r
1545   enterRule(_localctx, 46, TocParser::RuleForStmt);\r
1546 \r
1547 #if __cplusplus > 201703L\r
1548   auto onExit = finally([=, this] {\r
1549 #else\r
1550   auto onExit = finally([=] {\r
1551 #endif\r
1552     exitRule();\r
1553   });\r
1554   try {\r
1555     enterOuterAlt(_localctx, 1);\r
1556     setState(270);\r
1557     match(TocParser::T__20);\r
1558     setState(273);\r
1559     _errHandler->sync(this);\r
1560     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 18, _ctx)) {\r
1561     case 1: {\r
1562       setState(271);\r
1563       varInit();\r
1564       break;\r
1565     }\r
1566 \r
1567     case 2: {\r
1568       setState(272);\r
1569       assignStmt();\r
1570       break;\r
1571     }\r
1572 \r
1573     default:\r
1574       break;\r
1575     }\r
1576     setState(275);\r
1577     match(TocParser::T__10);\r
1578     setState(276);\r
1579     expr();\r
1580     setState(277);\r
1581     match(TocParser::T__10);\r
1582     setState(278);\r
1583     expr();\r
1584     setState(279);\r
1585     body();\r
1586    \r
1587   }\r
1588   catch (RecognitionException &e) {\r
1589     _errHandler->reportError(this, e);\r
1590     _localctx->exception = std::current_exception();\r
1591     _errHandler->recover(this, _localctx->exception);\r
1592   }\r
1593 \r
1594   return _localctx;\r
1595 }\r
1596 \r
1597 //----------------- WhileStmtContext ------------------------------------------------------------------\r
1598 \r
1599 TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1600   : ParserRuleContext(parent, invokingState) {\r
1601 }\r
1602 \r
1603 TocParser::ExprContext* TocParser::WhileStmtContext::expr() {\r
1604   return getRuleContext<TocParser::ExprContext>(0);\r
1605 }\r
1606 \r
1607 TocParser::BodyContext* TocParser::WhileStmtContext::body() {\r
1608   return getRuleContext<TocParser::BodyContext>(0);\r
1609 }\r
1610 \r
1611 \r
1612 size_t TocParser::WhileStmtContext::getRuleIndex() const {\r
1613   return TocParser::RuleWhileStmt;\r
1614 }\r
1615 \r
1616 \r
1617 TocParser::WhileStmtContext* TocParser::whileStmt() {\r
1618   WhileStmtContext *_localctx = _tracker.createInstance<WhileStmtContext>(_ctx, getState());\r
1619   enterRule(_localctx, 48, TocParser::RuleWhileStmt);\r
1620 \r
1621 #if __cplusplus > 201703L\r
1622   auto onExit = finally([=, this] {\r
1623 #else\r
1624   auto onExit = finally([=] {\r
1625 #endif\r
1626     exitRule();\r
1627   });\r
1628   try {\r
1629     enterOuterAlt(_localctx, 1);\r
1630     setState(281);\r
1631     match(TocParser::T__21);\r
1632     setState(282);\r
1633     expr();\r
1634     setState(283);\r
1635     body();\r
1636    \r
1637   }\r
1638   catch (RecognitionException &e) {\r
1639     _errHandler->reportError(this, e);\r
1640     _localctx->exception = std::current_exception();\r
1641     _errHandler->recover(this, _localctx->exception);\r
1642   }\r
1643 \r
1644   return _localctx;\r
1645 }\r
1646 \r
1647 //----------------- AssignStmtContext ------------------------------------------------------------------\r
1648 \r
1649 TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1650   : ParserRuleContext(parent, invokingState) {\r
1651 }\r
1652 \r
1653 TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() {\r
1654   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1655 }\r
1656 \r
1657 TocParser::ExprContext* TocParser::AssignStmtContext::expr() {\r
1658   return getRuleContext<TocParser::ExprContext>(0);\r
1659 }\r
1660 \r
1661 \r
1662 size_t TocParser::AssignStmtContext::getRuleIndex() const {\r
1663   return TocParser::RuleAssignStmt;\r
1664 }\r
1665 \r
1666 \r
1667 TocParser::AssignStmtContext* TocParser::assignStmt() {\r
1668   AssignStmtContext *_localctx = _tracker.createInstance<AssignStmtContext>(_ctx, getState());\r
1669   enterRule(_localctx, 50, TocParser::RuleAssignStmt);\r
1670 \r
1671 #if __cplusplus > 201703L\r
1672   auto onExit = finally([=, this] {\r
1673 #else\r
1674   auto onExit = finally([=] {\r
1675 #endif\r
1676     exitRule();\r
1677   });\r
1678   try {\r
1679     enterOuterAlt(_localctx, 1);\r
1680     setState(285);\r
1681     identifierExpr();\r
1682     setState(286);\r
1683     match(TocParser::T__3);\r
1684     setState(287);\r
1685     expr();\r
1686    \r
1687   }\r
1688   catch (RecognitionException &e) {\r
1689     _errHandler->reportError(this, e);\r
1690     _localctx->exception = std::current_exception();\r
1691     _errHandler->recover(this, _localctx->exception);\r
1692   }\r
1693 \r
1694   return _localctx;\r
1695 }\r
1696 \r
1697 //----------------- ReturnStmtContext ------------------------------------------------------------------\r
1698 \r
1699 TocParser::ReturnStmtContext::ReturnStmtContext(ParserRuleContext *parent, size_t invokingState)\r
1700   : ParserRuleContext(parent, invokingState) {\r
1701 }\r
1702 \r
1703 TocParser::ExprContext* TocParser::ReturnStmtContext::expr() {\r
1704   return getRuleContext<TocParser::ExprContext>(0);\r
1705 }\r
1706 \r
1707 \r
1708 size_t TocParser::ReturnStmtContext::getRuleIndex() const {\r
1709   return TocParser::RuleReturnStmt;\r
1710 }\r
1711 \r
1712 \r
1713 TocParser::ReturnStmtContext* TocParser::returnStmt() {\r
1714   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());\r
1715   enterRule(_localctx, 52, TocParser::RuleReturnStmt);\r
1716 \r
1717 #if __cplusplus > 201703L\r
1718   auto onExit = finally([=, this] {\r
1719 #else\r
1720   auto onExit = finally([=] {\r
1721 #endif\r
1722     exitRule();\r
1723   });\r
1724   try {\r
1725     enterOuterAlt(_localctx, 1);\r
1726     setState(289);\r
1727     match(TocParser::T__22);\r
1728     setState(290);\r
1729     expr();\r
1730    \r
1731   }\r
1732   catch (RecognitionException &e) {\r
1733     _errHandler->reportError(this, e);\r
1734     _localctx->exception = std::current_exception();\r
1735     _errHandler->recover(this, _localctx->exception);\r
1736   }\r
1737 \r
1738   return _localctx;\r
1739 }\r
1740 \r
1741 //----------------- ExprContext ------------------------------------------------------------------\r
1742 \r
1743 TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingState)\r
1744   : ParserRuleContext(parent, invokingState) {\r
1745 }\r
1746 \r
1747 TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() {\r
1748   return getRuleContext<TocParser::FuncExprContext>(0);\r
1749 }\r
1750 \r
1751 TocParser::LitExprContext* TocParser::ExprContext::litExpr() {\r
1752   return getRuleContext<TocParser::LitExprContext>(0);\r
1753 }\r
1754 \r
1755 TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() {\r
1756   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1757 }\r
1758 \r
1759 TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {\r
1760   return getRuleContext<TocParser::ParenExprContext>(0);\r
1761 }\r
1762 \r
1763 TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() {\r
1764   return getRuleContext<TocParser::AccessExprContext>(0);\r
1765 }\r
1766 \r
1767 TocParser::OpExprContext* TocParser::ExprContext::opExpr() {\r
1768   return getRuleContext<TocParser::OpExprContext>(0);\r
1769 }\r
1770 \r
1771 \r
1772 size_t TocParser::ExprContext::getRuleIndex() const {\r
1773   return TocParser::RuleExpr;\r
1774 }\r
1775 \r
1776 \r
1777 TocParser::ExprContext* TocParser::expr() {\r
1778   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());\r
1779   enterRule(_localctx, 54, TocParser::RuleExpr);\r
1780 \r
1781 #if __cplusplus > 201703L\r
1782   auto onExit = finally([=, this] {\r
1783 #else\r
1784   auto onExit = finally([=] {\r
1785 #endif\r
1786     exitRule();\r
1787   });\r
1788   try {\r
1789     setState(298);\r
1790     _errHandler->sync(this);\r
1791     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 19, _ctx)) {\r
1792     case 1: {\r
1793       enterOuterAlt(_localctx, 1);\r
1794       setState(292);\r
1795       funcExpr();\r
1796       break;\r
1797     }\r
1798 \r
1799     case 2: {\r
1800       enterOuterAlt(_localctx, 2);\r
1801       setState(293);\r
1802       litExpr();\r
1803       break;\r
1804     }\r
1805 \r
1806     case 3: {\r
1807       enterOuterAlt(_localctx, 3);\r
1808       setState(294);\r
1809       identifierExpr();\r
1810       break;\r
1811     }\r
1812 \r
1813     case 4: {\r
1814       enterOuterAlt(_localctx, 4);\r
1815       setState(295);\r
1816       parenExpr();\r
1817       break;\r
1818     }\r
1819 \r
1820     case 5: {\r
1821       enterOuterAlt(_localctx, 5);\r
1822       setState(296);\r
1823       accessExpr();\r
1824       break;\r
1825     }\r
1826 \r
1827     case 6: {\r
1828       enterOuterAlt(_localctx, 6);\r
1829       setState(297);\r
1830       opExpr();\r
1831       break;\r
1832     }\r
1833 \r
1834     default:\r
1835       break;\r
1836     }\r
1837    \r
1838   }\r
1839   catch (RecognitionException &e) {\r
1840     _errHandler->reportError(this, e);\r
1841     _localctx->exception = std::current_exception();\r
1842     _errHandler->recover(this, _localctx->exception);\r
1843   }\r
1844 \r
1845   return _localctx;\r
1846 }\r
1847 \r
1848 //----------------- NonOpExprContext ------------------------------------------------------------------\r
1849 \r
1850 TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t invokingState)\r
1851   : ParserRuleContext(parent, invokingState) {\r
1852 }\r
1853 \r
1854 TocParser::FuncExprContext* TocParser::NonOpExprContext::funcExpr() {\r
1855   return getRuleContext<TocParser::FuncExprContext>(0);\r
1856 }\r
1857 \r
1858 TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() {\r
1859   return getRuleContext<TocParser::LitExprContext>(0);\r
1860 }\r
1861 \r
1862 TocParser::IdentifierExprContext* TocParser::NonOpExprContext::identifierExpr() {\r
1863   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1864 }\r
1865 \r
1866 TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {\r
1867   return getRuleContext<TocParser::ParenExprContext>(0);\r
1868 }\r
1869 \r
1870 TocParser::AccessExprContext* TocParser::NonOpExprContext::accessExpr() {\r
1871   return getRuleContext<TocParser::AccessExprContext>(0);\r
1872 }\r
1873 \r
1874 \r
1875 size_t TocParser::NonOpExprContext::getRuleIndex() const {\r
1876   return TocParser::RuleNonOpExpr;\r
1877 }\r
1878 \r
1879 \r
1880 TocParser::NonOpExprContext* TocParser::nonOpExpr() {\r
1881   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());\r
1882   enterRule(_localctx, 56, TocParser::RuleNonOpExpr);\r
1883 \r
1884 #if __cplusplus > 201703L\r
1885   auto onExit = finally([=, this] {\r
1886 #else\r
1887   auto onExit = finally([=] {\r
1888 #endif\r
1889     exitRule();\r
1890   });\r
1891   try {\r
1892     setState(305);\r
1893     _errHandler->sync(this);\r
1894     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 20, _ctx)) {\r
1895     case 1: {\r
1896       enterOuterAlt(_localctx, 1);\r
1897       setState(300);\r
1898       funcExpr();\r
1899       break;\r
1900     }\r
1901 \r
1902     case 2: {\r
1903       enterOuterAlt(_localctx, 2);\r
1904       setState(301);\r
1905       litExpr();\r
1906       break;\r
1907     }\r
1908 \r
1909     case 3: {\r
1910       enterOuterAlt(_localctx, 3);\r
1911       setState(302);\r
1912       identifierExpr();\r
1913       break;\r
1914     }\r
1915 \r
1916     case 4: {\r
1917       enterOuterAlt(_localctx, 4);\r
1918       setState(303);\r
1919       parenExpr();\r
1920       break;\r
1921     }\r
1922 \r
1923     case 5: {\r
1924       enterOuterAlt(_localctx, 5);\r
1925       setState(304);\r
1926       accessExpr();\r
1927       break;\r
1928     }\r
1929 \r
1930     default:\r
1931       break;\r
1932     }\r
1933    \r
1934   }\r
1935   catch (RecognitionException &e) {\r
1936     _errHandler->reportError(this, e);\r
1937     _localctx->exception = std::current_exception();\r
1938     _errHandler->recover(this, _localctx->exception);\r
1939   }\r
1940 \r
1941   return _localctx;\r
1942 }\r
1943 \r
1944 //----------------- NonAccessExprContext ------------------------------------------------------------------\r
1945 \r
1946 TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState)\r
1947   : ParserRuleContext(parent, invokingState) {\r
1948 }\r
1949 \r
1950 TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() {\r
1951   return getRuleContext<TocParser::FuncExprContext>(0);\r
1952 }\r
1953 \r
1954 TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() {\r
1955   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
1956 }\r
1957 \r
1958 TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() {\r
1959   return getRuleContext<TocParser::ParenExprContext>(0);\r
1960 }\r
1961 \r
1962 \r
1963 size_t TocParser::NonAccessExprContext::getRuleIndex() const {\r
1964   return TocParser::RuleNonAccessExpr;\r
1965 }\r
1966 \r
1967 \r
1968 TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {\r
1969   NonAccessExprContext *_localctx = _tracker.createInstance<NonAccessExprContext>(_ctx, getState());\r
1970   enterRule(_localctx, 58, TocParser::RuleNonAccessExpr);\r
1971 \r
1972 #if __cplusplus > 201703L\r
1973   auto onExit = finally([=, this] {\r
1974 #else\r
1975   auto onExit = finally([=] {\r
1976 #endif\r
1977     exitRule();\r
1978   });\r
1979   try {\r
1980     setState(310);\r
1981     _errHandler->sync(this);\r
1982     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 21, _ctx)) {\r
1983     case 1: {\r
1984       enterOuterAlt(_localctx, 1);\r
1985       setState(307);\r
1986       funcExpr();\r
1987       break;\r
1988     }\r
1989 \r
1990     case 2: {\r
1991       enterOuterAlt(_localctx, 2);\r
1992       setState(308);\r
1993       identifierExpr();\r
1994       break;\r
1995     }\r
1996 \r
1997     case 3: {\r
1998       enterOuterAlt(_localctx, 3);\r
1999       setState(309);\r
2000       parenExpr();\r
2001       break;\r
2002     }\r
2003 \r
2004     default:\r
2005       break;\r
2006     }\r
2007    \r
2008   }\r
2009   catch (RecognitionException &e) {\r
2010     _errHandler->reportError(this, e);\r
2011     _localctx->exception = std::current_exception();\r
2012     _errHandler->recover(this, _localctx->exception);\r
2013   }\r
2014 \r
2015   return _localctx;\r
2016 }\r
2017 \r
2018 //----------------- FuncExprContext ------------------------------------------------------------------\r
2019 \r
2020 TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState)\r
2021   : ParserRuleContext(parent, invokingState) {\r
2022 }\r
2023 \r
2024 TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() {\r
2025   return getRuleContext<TocParser::FuncNameContext>(0);\r
2026 }\r
2027 \r
2028 std::vector<TocParser::ExprContext *> TocParser::FuncExprContext::expr() {\r
2029   return getRuleContexts<TocParser::ExprContext>();\r
2030 }\r
2031 \r
2032 TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) {\r
2033   return getRuleContext<TocParser::ExprContext>(i);\r
2034 }\r
2035 \r
2036 \r
2037 size_t TocParser::FuncExprContext::getRuleIndex() const {\r
2038   return TocParser::RuleFuncExpr;\r
2039 }\r
2040 \r
2041 \r
2042 TocParser::FuncExprContext* TocParser::funcExpr() {\r
2043   FuncExprContext *_localctx = _tracker.createInstance<FuncExprContext>(_ctx, getState());\r
2044   enterRule(_localctx, 60, TocParser::RuleFuncExpr);\r
2045   size_t _la = 0;\r
2046 \r
2047 #if __cplusplus > 201703L\r
2048   auto onExit = finally([=, this] {\r
2049 #else\r
2050   auto onExit = finally([=] {\r
2051 #endif\r
2052     exitRule();\r
2053   });\r
2054   try {\r
2055     enterOuterAlt(_localctx, 1);\r
2056     setState(312);\r
2057     funcName();\r
2058     setState(313);\r
2059     match(TocParser::T__8);\r
2060     setState(322);\r
2061     _errHandler->sync(this);\r
2062 \r
2063     _la = _input->LA(1);\r
2064     if ((((_la & ~ 0x3fULL) == 0) &&\r
2065       ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
2066       | (1ULL << TocParser::T__8)\r
2067       | (1ULL << TocParser::T__26)\r
2068       | (1ULL << TocParser::T__27)\r
2069       | (1ULL << TocParser::T__28)\r
2070       | (1ULL << TocParser::T__29)\r
2071       | (1ULL << TocParser::T__30)\r
2072       | (1ULL << TocParser::T__31)\r
2073       | (1ULL << TocParser::T__32)\r
2074       | (1ULL << TocParser::INT_LIT)\r
2075       | (1ULL << TocParser::DECIMAL_LIT)\r
2076       | (1ULL << TocParser::STRING_LIT)\r
2077       | (1ULL << TocParser::BOOL_LIT)\r
2078       | (1ULL << TocParser::NAME))) != 0)) {\r
2079       setState(314);\r
2080       expr();\r
2081       setState(319);\r
2082       _errHandler->sync(this);\r
2083       _la = _input->LA(1);\r
2084       while (_la == TocParser::T__10) {\r
2085         setState(315);\r
2086         match(TocParser::T__10);\r
2087         setState(316);\r
2088         expr();\r
2089         setState(321);\r
2090         _errHandler->sync(this);\r
2091         _la = _input->LA(1);\r
2092       }\r
2093     }\r
2094     setState(324);\r
2095     match(TocParser::T__9);\r
2096    \r
2097   }\r
2098   catch (RecognitionException &e) {\r
2099     _errHandler->reportError(this, e);\r
2100     _localctx->exception = std::current_exception();\r
2101     _errHandler->recover(this, _localctx->exception);\r
2102   }\r
2103 \r
2104   return _localctx;\r
2105 }\r
2106 \r
2107 //----------------- OpExprContext ------------------------------------------------------------------\r
2108 \r
2109 TocParser::OpExprContext::OpExprContext(ParserRuleContext *parent, size_t invokingState)\r
2110   : ParserRuleContext(parent, invokingState) {\r
2111 }\r
2112 \r
2113 TocParser::BinaryOpContext* TocParser::OpExprContext::binaryOp() {\r
2114   return getRuleContext<TocParser::BinaryOpContext>(0);\r
2115 }\r
2116 \r
2117 TocParser::PrefixOpContext* TocParser::OpExprContext::prefixOp() {\r
2118   return getRuleContext<TocParser::PrefixOpContext>(0);\r
2119 }\r
2120 \r
2121 TocParser::PostfixOpContext* TocParser::OpExprContext::postfixOp() {\r
2122   return getRuleContext<TocParser::PostfixOpContext>(0);\r
2123 }\r
2124 \r
2125 TocParser::TernaryOpContext* TocParser::OpExprContext::ternaryOp() {\r
2126   return getRuleContext<TocParser::TernaryOpContext>(0);\r
2127 }\r
2128 \r
2129 \r
2130 size_t TocParser::OpExprContext::getRuleIndex() const {\r
2131   return TocParser::RuleOpExpr;\r
2132 }\r
2133 \r
2134 \r
2135 TocParser::OpExprContext* TocParser::opExpr() {\r
2136   OpExprContext *_localctx = _tracker.createInstance<OpExprContext>(_ctx, getState());\r
2137   enterRule(_localctx, 62, TocParser::RuleOpExpr);\r
2138 \r
2139 #if __cplusplus > 201703L\r
2140   auto onExit = finally([=, this] {\r
2141 #else\r
2142   auto onExit = finally([=] {\r
2143 #endif\r
2144     exitRule();\r
2145   });\r
2146   try {\r
2147     setState(330);\r
2148     _errHandler->sync(this);\r
2149     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 24, _ctx)) {\r
2150     case 1: {\r
2151       enterOuterAlt(_localctx, 1);\r
2152       setState(326);\r
2153       binaryOp();\r
2154       break;\r
2155     }\r
2156 \r
2157     case 2: {\r
2158       enterOuterAlt(_localctx, 2);\r
2159       setState(327);\r
2160       prefixOp();\r
2161       break;\r
2162     }\r
2163 \r
2164     case 3: {\r
2165       enterOuterAlt(_localctx, 3);\r
2166       setState(328);\r
2167       postfixOp();\r
2168       break;\r
2169     }\r
2170 \r
2171     case 4: {\r
2172       enterOuterAlt(_localctx, 4);\r
2173       setState(329);\r
2174       ternaryOp();\r
2175       break;\r
2176     }\r
2177 \r
2178     default:\r
2179       break;\r
2180     }\r
2181    \r
2182   }\r
2183   catch (RecognitionException &e) {\r
2184     _errHandler->reportError(this, e);\r
2185     _localctx->exception = std::current_exception();\r
2186     _errHandler->recover(this, _localctx->exception);\r
2187   }\r
2188 \r
2189   return _localctx;\r
2190 }\r
2191 \r
2192 //----------------- BinaryOpContext ------------------------------------------------------------------\r
2193 \r
2194 TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState)\r
2195   : ParserRuleContext(parent, invokingState) {\r
2196 }\r
2197 \r
2198 std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOpContext::nonOpExpr() {\r
2199   return getRuleContexts<TocParser::NonOpExprContext>();\r
2200 }\r
2201 \r
2202 TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) {\r
2203   return getRuleContext<TocParser::NonOpExprContext>(i);\r
2204 }\r
2205 \r
2206 std::vector<TocParser::Binary_opContext *> TocParser::BinaryOpContext::binary_op() {\r
2207   return getRuleContexts<TocParser::Binary_opContext>();\r
2208 }\r
2209 \r
2210 TocParser::Binary_opContext* TocParser::BinaryOpContext::binary_op(size_t i) {\r
2211   return getRuleContext<TocParser::Binary_opContext>(i);\r
2212 }\r
2213 \r
2214 \r
2215 size_t TocParser::BinaryOpContext::getRuleIndex() const {\r
2216   return TocParser::RuleBinaryOp;\r
2217 }\r
2218 \r
2219 \r
2220 TocParser::BinaryOpContext* TocParser::binaryOp() {\r
2221   BinaryOpContext *_localctx = _tracker.createInstance<BinaryOpContext>(_ctx, getState());\r
2222   enterRule(_localctx, 64, TocParser::RuleBinaryOp);\r
2223   size_t _la = 0;\r
2224 \r
2225 #if __cplusplus > 201703L\r
2226   auto onExit = finally([=, this] {\r
2227 #else\r
2228   auto onExit = finally([=] {\r
2229 #endif\r
2230     exitRule();\r
2231   });\r
2232   try {\r
2233     enterOuterAlt(_localctx, 1);\r
2234     setState(332);\r
2235     nonOpExpr();\r
2236     setState(333);\r
2237     binary_op();\r
2238     setState(334);\r
2239     nonOpExpr();\r
2240     setState(340);\r
2241     _errHandler->sync(this);\r
2242     _la = _input->LA(1);\r
2243     while ((((_la & ~ 0x3fULL) == 0) &&\r
2244       ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
2245       | (1ULL << TocParser::T__14)\r
2246       | (1ULL << TocParser::T__15)\r
2247       | (1ULL << TocParser::T__28)\r
2248       | (1ULL << TocParser::T__29)\r
2249       | (1ULL << TocParser::T__32)\r
2250       | (1ULL << TocParser::T__33)\r
2251       | (1ULL << TocParser::T__34)\r
2252       | (1ULL << TocParser::T__35)\r
2253       | (1ULL << TocParser::T__36)\r
2254       | (1ULL << TocParser::T__37)\r
2255       | (1ULL << TocParser::T__38)\r
2256       | (1ULL << TocParser::T__39)\r
2257       | (1ULL << TocParser::T__40)\r
2258       | (1ULL << TocParser::T__41)\r
2259       | (1ULL << TocParser::T__42)\r
2260       | (1ULL << TocParser::T__43)\r
2261       | (1ULL << TocParser::T__44)\r
2262       | (1ULL << TocParser::T__45)\r
2263       | (1ULL << TocParser::T__46)\r
2264       | (1ULL << TocParser::T__47)\r
2265       | (1ULL << TocParser::T__48)\r
2266       | (1ULL << TocParser::T__49)\r
2267       | (1ULL << TocParser::T__50)\r
2268       | (1ULL << TocParser::T__51)\r
2269       | (1ULL << TocParser::T__52)\r
2270       | (1ULL << TocParser::T__53)\r
2271       | (1ULL << TocParser::T__54))) != 0)) {\r
2272       setState(335);\r
2273       binary_op();\r
2274       setState(336);\r
2275       nonOpExpr();\r
2276       setState(342);\r
2277       _errHandler->sync(this);\r
2278       _la = _input->LA(1);\r
2279     }\r
2280    \r
2281   }\r
2282   catch (RecognitionException &e) {\r
2283     _errHandler->reportError(this, e);\r
2284     _localctx->exception = std::current_exception();\r
2285     _errHandler->recover(this, _localctx->exception);\r
2286   }\r
2287 \r
2288   return _localctx;\r
2289 }\r
2290 \r
2291 //----------------- PrefixOpContext ------------------------------------------------------------------\r
2292 \r
2293 TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState)\r
2294   : ParserRuleContext(parent, invokingState) {\r
2295 }\r
2296 \r
2297 TocParser::Prefix_opContext* TocParser::PrefixOpContext::prefix_op() {\r
2298   return getRuleContext<TocParser::Prefix_opContext>(0);\r
2299 }\r
2300 \r
2301 TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() {\r
2302   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2303 }\r
2304 \r
2305 \r
2306 size_t TocParser::PrefixOpContext::getRuleIndex() const {\r
2307   return TocParser::RulePrefixOp;\r
2308 }\r
2309 \r
2310 \r
2311 TocParser::PrefixOpContext* TocParser::prefixOp() {\r
2312   PrefixOpContext *_localctx = _tracker.createInstance<PrefixOpContext>(_ctx, getState());\r
2313   enterRule(_localctx, 66, TocParser::RulePrefixOp);\r
2314 \r
2315 #if __cplusplus > 201703L\r
2316   auto onExit = finally([=, this] {\r
2317 #else\r
2318   auto onExit = finally([=] {\r
2319 #endif\r
2320     exitRule();\r
2321   });\r
2322   try {\r
2323     enterOuterAlt(_localctx, 1);\r
2324     setState(343);\r
2325     prefix_op();\r
2326     setState(344);\r
2327     nonOpExpr();\r
2328    \r
2329   }\r
2330   catch (RecognitionException &e) {\r
2331     _errHandler->reportError(this, e);\r
2332     _localctx->exception = std::current_exception();\r
2333     _errHandler->recover(this, _localctx->exception);\r
2334   }\r
2335 \r
2336   return _localctx;\r
2337 }\r
2338 \r
2339 //----------------- PostfixOpContext ------------------------------------------------------------------\r
2340 \r
2341 TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState)\r
2342   : ParserRuleContext(parent, invokingState) {\r
2343 }\r
2344 \r
2345 TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() {\r
2346   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2347 }\r
2348 \r
2349 TocParser::Postfix_opContext* TocParser::PostfixOpContext::postfix_op() {\r
2350   return getRuleContext<TocParser::Postfix_opContext>(0);\r
2351 }\r
2352 \r
2353 \r
2354 size_t TocParser::PostfixOpContext::getRuleIndex() const {\r
2355   return TocParser::RulePostfixOp;\r
2356 }\r
2357 \r
2358 \r
2359 TocParser::PostfixOpContext* TocParser::postfixOp() {\r
2360   PostfixOpContext *_localctx = _tracker.createInstance<PostfixOpContext>(_ctx, getState());\r
2361   enterRule(_localctx, 68, TocParser::RulePostfixOp);\r
2362 \r
2363 #if __cplusplus > 201703L\r
2364   auto onExit = finally([=, this] {\r
2365 #else\r
2366   auto onExit = finally([=] {\r
2367 #endif\r
2368     exitRule();\r
2369   });\r
2370   try {\r
2371     enterOuterAlt(_localctx, 1);\r
2372     setState(346);\r
2373     nonOpExpr();\r
2374     setState(347);\r
2375     postfix_op();\r
2376    \r
2377   }\r
2378   catch (RecognitionException &e) {\r
2379     _errHandler->reportError(this, e);\r
2380     _localctx->exception = std::current_exception();\r
2381     _errHandler->recover(this, _localctx->exception);\r
2382   }\r
2383 \r
2384   return _localctx;\r
2385 }\r
2386 \r
2387 //----------------- TernaryOpContext ------------------------------------------------------------------\r
2388 \r
2389 TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState)\r
2390   : ParserRuleContext(parent, invokingState) {\r
2391 }\r
2392 \r
2393 TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() {\r
2394   return getRuleContext<TocParser::NonOpExprContext>(0);\r
2395 }\r
2396 \r
2397 std::vector<TocParser::ExprContext *> TocParser::TernaryOpContext::expr() {\r
2398   return getRuleContexts<TocParser::ExprContext>();\r
2399 }\r
2400 \r
2401 TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) {\r
2402   return getRuleContext<TocParser::ExprContext>(i);\r
2403 }\r
2404 \r
2405 \r
2406 size_t TocParser::TernaryOpContext::getRuleIndex() const {\r
2407   return TocParser::RuleTernaryOp;\r
2408 }\r
2409 \r
2410 \r
2411 TocParser::TernaryOpContext* TocParser::ternaryOp() {\r
2412   TernaryOpContext *_localctx = _tracker.createInstance<TernaryOpContext>(_ctx, getState());\r
2413   enterRule(_localctx, 70, TocParser::RuleTernaryOp);\r
2414 \r
2415 #if __cplusplus > 201703L\r
2416   auto onExit = finally([=, this] {\r
2417 #else\r
2418   auto onExit = finally([=] {\r
2419 #endif\r
2420     exitRule();\r
2421   });\r
2422   try {\r
2423     enterOuterAlt(_localctx, 1);\r
2424     setState(349);\r
2425     nonOpExpr();\r
2426     setState(350);\r
2427     match(TocParser::T__23);\r
2428     setState(351);\r
2429     expr();\r
2430     setState(352);\r
2431     match(TocParser::T__2);\r
2432     setState(353);\r
2433     expr();\r
2434    \r
2435   }\r
2436   catch (RecognitionException &e) {\r
2437     _errHandler->reportError(this, e);\r
2438     _localctx->exception = std::current_exception();\r
2439     _errHandler->recover(this, _localctx->exception);\r
2440   }\r
2441 \r
2442   return _localctx;\r
2443 }\r
2444 \r
2445 //----------------- IdentifierExprContext ------------------------------------------------------------------\r
2446 \r
2447 TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState)\r
2448   : ParserRuleContext(parent, invokingState) {\r
2449 }\r
2450 \r
2451 TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() {\r
2452   return getRuleContext<TocParser::VarNameContext>(0);\r
2453 }\r
2454 \r
2455 \r
2456 size_t TocParser::IdentifierExprContext::getRuleIndex() const {\r
2457   return TocParser::RuleIdentifierExpr;\r
2458 }\r
2459 \r
2460 \r
2461 TocParser::IdentifierExprContext* TocParser::identifierExpr() {\r
2462   IdentifierExprContext *_localctx = _tracker.createInstance<IdentifierExprContext>(_ctx, getState());\r
2463   enterRule(_localctx, 72, TocParser::RuleIdentifierExpr);\r
2464 \r
2465 #if __cplusplus > 201703L\r
2466   auto onExit = finally([=, this] {\r
2467 #else\r
2468   auto onExit = finally([=] {\r
2469 #endif\r
2470     exitRule();\r
2471   });\r
2472   try {\r
2473     enterOuterAlt(_localctx, 1);\r
2474     setState(355);\r
2475     varName();\r
2476    \r
2477   }\r
2478   catch (RecognitionException &e) {\r
2479     _errHandler->reportError(this, e);\r
2480     _localctx->exception = std::current_exception();\r
2481     _errHandler->recover(this, _localctx->exception);\r
2482   }\r
2483 \r
2484   return _localctx;\r
2485 }\r
2486 \r
2487 //----------------- LitExprContext ------------------------------------------------------------------\r
2488 \r
2489 TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState)\r
2490   : ParserRuleContext(parent, invokingState) {\r
2491 }\r
2492 \r
2493 tree::TerminalNode* TocParser::LitExprContext::INT_LIT() {\r
2494   return getToken(TocParser::INT_LIT, 0);\r
2495 }\r
2496 \r
2497 tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() {\r
2498   return getToken(TocParser::DECIMAL_LIT, 0);\r
2499 }\r
2500 \r
2501 tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() {\r
2502   return getToken(TocParser::STRING_LIT, 0);\r
2503 }\r
2504 \r
2505 tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() {\r
2506   return getToken(TocParser::BOOL_LIT, 0);\r
2507 }\r
2508 \r
2509 \r
2510 size_t TocParser::LitExprContext::getRuleIndex() const {\r
2511   return TocParser::RuleLitExpr;\r
2512 }\r
2513 \r
2514 \r
2515 TocParser::LitExprContext* TocParser::litExpr() {\r
2516   LitExprContext *_localctx = _tracker.createInstance<LitExprContext>(_ctx, getState());\r
2517   enterRule(_localctx, 74, TocParser::RuleLitExpr);\r
2518   size_t _la = 0;\r
2519 \r
2520 #if __cplusplus > 201703L\r
2521   auto onExit = finally([=, this] {\r
2522 #else\r
2523   auto onExit = finally([=] {\r
2524 #endif\r
2525     exitRule();\r
2526   });\r
2527   try {\r
2528     enterOuterAlt(_localctx, 1);\r
2529     setState(357);\r
2530     _la = _input->LA(1);\r
2531     if (!((((_la & ~ 0x3fULL) == 0) &&\r
2532       ((1ULL << _la) & ((1ULL << TocParser::INT_LIT)\r
2533       | (1ULL << TocParser::DECIMAL_LIT)\r
2534       | (1ULL << TocParser::STRING_LIT)\r
2535       | (1ULL << TocParser::BOOL_LIT))) != 0))) {\r
2536     _errHandler->recoverInline(this);\r
2537     }\r
2538     else {\r
2539       _errHandler->reportMatch(this);\r
2540       consume();\r
2541     }\r
2542    \r
2543   }\r
2544   catch (RecognitionException &e) {\r
2545     _errHandler->reportError(this, e);\r
2546     _localctx->exception = std::current_exception();\r
2547     _errHandler->recover(this, _localctx->exception);\r
2548   }\r
2549 \r
2550   return _localctx;\r
2551 }\r
2552 \r
2553 //----------------- AccessExprContext ------------------------------------------------------------------\r
2554 \r
2555 TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState)\r
2556   : ParserRuleContext(parent, invokingState) {\r
2557 }\r
2558 \r
2559 TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() {\r
2560   return getRuleContext<TocParser::NonAccessExprContext>(0);\r
2561 }\r
2562 \r
2563 std::vector<TocParser::AccessSubExprContext *> TocParser::AccessExprContext::accessSubExpr() {\r
2564   return getRuleContexts<TocParser::AccessSubExprContext>();\r
2565 }\r
2566 \r
2567 TocParser::AccessSubExprContext* TocParser::AccessExprContext::accessSubExpr(size_t i) {\r
2568   return getRuleContext<TocParser::AccessSubExprContext>(i);\r
2569 }\r
2570 \r
2571 \r
2572 size_t TocParser::AccessExprContext::getRuleIndex() const {\r
2573   return TocParser::RuleAccessExpr;\r
2574 }\r
2575 \r
2576 \r
2577 TocParser::AccessExprContext* TocParser::accessExpr() {\r
2578   AccessExprContext *_localctx = _tracker.createInstance<AccessExprContext>(_ctx, getState());\r
2579   enterRule(_localctx, 76, TocParser::RuleAccessExpr);\r
2580   size_t _la = 0;\r
2581 \r
2582 #if __cplusplus > 201703L\r
2583   auto onExit = finally([=, this] {\r
2584 #else\r
2585   auto onExit = finally([=] {\r
2586 #endif\r
2587     exitRule();\r
2588   });\r
2589   try {\r
2590     enterOuterAlt(_localctx, 1);\r
2591     setState(359);\r
2592     nonAccessExpr();\r
2593     setState(361); \r
2594     _errHandler->sync(this);\r
2595     _la = _input->LA(1);\r
2596     do {\r
2597       setState(360);\r
2598       accessSubExpr();\r
2599       setState(363); \r
2600       _errHandler->sync(this);\r
2601       _la = _input->LA(1);\r
2602     } while ((((_la & ~ 0x3fULL) == 0) &&\r
2603       ((1ULL << _la) & ((1ULL << TocParser::T__5)\r
2604       | (1ULL << TocParser::T__24)\r
2605       | (1ULL << TocParser::T__25))) != 0));\r
2606    \r
2607   }\r
2608   catch (RecognitionException &e) {\r
2609     _errHandler->reportError(this, e);\r
2610     _localctx->exception = std::current_exception();\r
2611     _errHandler->recover(this, _localctx->exception);\r
2612   }\r
2613 \r
2614   return _localctx;\r
2615 }\r
2616 \r
2617 //----------------- AccessSubExprContext ------------------------------------------------------------------\r
2618 \r
2619 TocParser::AccessSubExprContext::AccessSubExprContext(ParserRuleContext *parent, size_t invokingState)\r
2620   : ParserRuleContext(parent, invokingState) {\r
2621 }\r
2622 \r
2623 TocParser::AccessMemberContext* TocParser::AccessSubExprContext::accessMember() {\r
2624   return getRuleContext<TocParser::AccessMemberContext>(0);\r
2625 }\r
2626 \r
2627 TocParser::AccessBracketsContext* TocParser::AccessSubExprContext::accessBrackets() {\r
2628   return getRuleContext<TocParser::AccessBracketsContext>(0);\r
2629 }\r
2630 \r
2631 \r
2632 size_t TocParser::AccessSubExprContext::getRuleIndex() const {\r
2633   return TocParser::RuleAccessSubExpr;\r
2634 }\r
2635 \r
2636 \r
2637 TocParser::AccessSubExprContext* TocParser::accessSubExpr() {\r
2638   AccessSubExprContext *_localctx = _tracker.createInstance<AccessSubExprContext>(_ctx, getState());\r
2639   enterRule(_localctx, 78, TocParser::RuleAccessSubExpr);\r
2640 \r
2641 #if __cplusplus > 201703L\r
2642   auto onExit = finally([=, this] {\r
2643 #else\r
2644   auto onExit = finally([=] {\r
2645 #endif\r
2646     exitRule();\r
2647   });\r
2648   try {\r
2649     setState(367);\r
2650     _errHandler->sync(this);\r
2651     switch (_input->LA(1)) {\r
2652       case TocParser::T__24:\r
2653       case TocParser::T__25: {\r
2654         enterOuterAlt(_localctx, 1);\r
2655         setState(365);\r
2656         accessMember();\r
2657         break;\r
2658       }\r
2659 \r
2660       case TocParser::T__5: {\r
2661         enterOuterAlt(_localctx, 2);\r
2662         setState(366);\r
2663         accessBrackets();\r
2664         break;\r
2665       }\r
2666 \r
2667     default:\r
2668       throw NoViableAltException(this);\r
2669     }\r
2670    \r
2671   }\r
2672   catch (RecognitionException &e) {\r
2673     _errHandler->reportError(this, e);\r
2674     _localctx->exception = std::current_exception();\r
2675     _errHandler->recover(this, _localctx->exception);\r
2676   }\r
2677 \r
2678   return _localctx;\r
2679 }\r
2680 \r
2681 //----------------- AccessMemberContext ------------------------------------------------------------------\r
2682 \r
2683 TocParser::AccessMemberContext::AccessMemberContext(ParserRuleContext *parent, size_t invokingState)\r
2684   : ParserRuleContext(parent, invokingState) {\r
2685 }\r
2686 \r
2687 TocParser::IdentifierExprContext* TocParser::AccessMemberContext::identifierExpr() {\r
2688   return getRuleContext<TocParser::IdentifierExprContext>(0);\r
2689 }\r
2690 \r
2691 \r
2692 size_t TocParser::AccessMemberContext::getRuleIndex() const {\r
2693   return TocParser::RuleAccessMember;\r
2694 }\r
2695 \r
2696 \r
2697 TocParser::AccessMemberContext* TocParser::accessMember() {\r
2698   AccessMemberContext *_localctx = _tracker.createInstance<AccessMemberContext>(_ctx, getState());\r
2699   enterRule(_localctx, 80, TocParser::RuleAccessMember);\r
2700   size_t _la = 0;\r
2701 \r
2702 #if __cplusplus > 201703L\r
2703   auto onExit = finally([=, this] {\r
2704 #else\r
2705   auto onExit = finally([=] {\r
2706 #endif\r
2707     exitRule();\r
2708   });\r
2709   try {\r
2710     enterOuterAlt(_localctx, 1);\r
2711     setState(369);\r
2712     _la = _input->LA(1);\r
2713     if (!(_la == TocParser::T__24\r
2714 \r
2715     || _la == TocParser::T__25)) {\r
2716     _errHandler->recoverInline(this);\r
2717     }\r
2718     else {\r
2719       _errHandler->reportMatch(this);\r
2720       consume();\r
2721     }\r
2722     setState(370);\r
2723     identifierExpr();\r
2724    \r
2725   }\r
2726   catch (RecognitionException &e) {\r
2727     _errHandler->reportError(this, e);\r
2728     _localctx->exception = std::current_exception();\r
2729     _errHandler->recover(this, _localctx->exception);\r
2730   }\r
2731 \r
2732   return _localctx;\r
2733 }\r
2734 \r
2735 //----------------- AccessBracketsContext ------------------------------------------------------------------\r
2736 \r
2737 TocParser::AccessBracketsContext::AccessBracketsContext(ParserRuleContext *parent, size_t invokingState)\r
2738   : ParserRuleContext(parent, invokingState) {\r
2739 }\r
2740 \r
2741 TocParser::ExprContext* TocParser::AccessBracketsContext::expr() {\r
2742   return getRuleContext<TocParser::ExprContext>(0);\r
2743 }\r
2744 \r
2745 \r
2746 size_t TocParser::AccessBracketsContext::getRuleIndex() const {\r
2747   return TocParser::RuleAccessBrackets;\r
2748 }\r
2749 \r
2750 \r
2751 TocParser::AccessBracketsContext* TocParser::accessBrackets() {\r
2752   AccessBracketsContext *_localctx = _tracker.createInstance<AccessBracketsContext>(_ctx, getState());\r
2753   enterRule(_localctx, 82, TocParser::RuleAccessBrackets);\r
2754 \r
2755 #if __cplusplus > 201703L\r
2756   auto onExit = finally([=, this] {\r
2757 #else\r
2758   auto onExit = finally([=] {\r
2759 #endif\r
2760     exitRule();\r
2761   });\r
2762   try {\r
2763     enterOuterAlt(_localctx, 1);\r
2764     setState(372);\r
2765     match(TocParser::T__5);\r
2766     setState(373);\r
2767     expr();\r
2768     setState(374);\r
2769     match(TocParser::T__6);\r
2770    \r
2771   }\r
2772   catch (RecognitionException &e) {\r
2773     _errHandler->reportError(this, e);\r
2774     _localctx->exception = std::current_exception();\r
2775     _errHandler->recover(this, _localctx->exception);\r
2776   }\r
2777 \r
2778   return _localctx;\r
2779 }\r
2780 \r
2781 //----------------- ParenExprContext ------------------------------------------------------------------\r
2782 \r
2783 TocParser::ParenExprContext::ParenExprContext(ParserRuleContext *parent, size_t invokingState)\r
2784   : ParserRuleContext(parent, invokingState) {\r
2785 }\r
2786 \r
2787 TocParser::ExprContext* TocParser::ParenExprContext::expr() {\r
2788   return getRuleContext<TocParser::ExprContext>(0);\r
2789 }\r
2790 \r
2791 \r
2792 size_t TocParser::ParenExprContext::getRuleIndex() const {\r
2793   return TocParser::RuleParenExpr;\r
2794 }\r
2795 \r
2796 \r
2797 TocParser::ParenExprContext* TocParser::parenExpr() {\r
2798   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());\r
2799   enterRule(_localctx, 84, TocParser::RuleParenExpr);\r
2800 \r
2801 #if __cplusplus > 201703L\r
2802   auto onExit = finally([=, this] {\r
2803 #else\r
2804   auto onExit = finally([=] {\r
2805 #endif\r
2806     exitRule();\r
2807   });\r
2808   try {\r
2809     enterOuterAlt(_localctx, 1);\r
2810     setState(376);\r
2811     match(TocParser::T__8);\r
2812     setState(377);\r
2813     expr();\r
2814     setState(378);\r
2815     match(TocParser::T__9);\r
2816    \r
2817   }\r
2818   catch (RecognitionException &e) {\r
2819     _errHandler->reportError(this, e);\r
2820     _localctx->exception = std::current_exception();\r
2821     _errHandler->recover(this, _localctx->exception);\r
2822   }\r
2823 \r
2824   return _localctx;\r
2825 }\r
2826 \r
2827 //----------------- FuncNameContext ------------------------------------------------------------------\r
2828 \r
2829 TocParser::FuncNameContext::FuncNameContext(ParserRuleContext *parent, size_t invokingState)\r
2830   : ParserRuleContext(parent, invokingState) {\r
2831 }\r
2832 \r
2833 tree::TerminalNode* TocParser::FuncNameContext::NAME() {\r
2834   return getToken(TocParser::NAME, 0);\r
2835 }\r
2836 \r
2837 \r
2838 size_t TocParser::FuncNameContext::getRuleIndex() const {\r
2839   return TocParser::RuleFuncName;\r
2840 }\r
2841 \r
2842 \r
2843 TocParser::FuncNameContext* TocParser::funcName() {\r
2844   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());\r
2845   enterRule(_localctx, 86, TocParser::RuleFuncName);\r
2846 \r
2847 #if __cplusplus > 201703L\r
2848   auto onExit = finally([=, this] {\r
2849 #else\r
2850   auto onExit = finally([=] {\r
2851 #endif\r
2852     exitRule();\r
2853   });\r
2854   try {\r
2855     enterOuterAlt(_localctx, 1);\r
2856     setState(380);\r
2857     match(TocParser::NAME);\r
2858    \r
2859   }\r
2860   catch (RecognitionException &e) {\r
2861     _errHandler->reportError(this, e);\r
2862     _localctx->exception = std::current_exception();\r
2863     _errHandler->recover(this, _localctx->exception);\r
2864   }\r
2865 \r
2866   return _localctx;\r
2867 }\r
2868 \r
2869 //----------------- VarNameContext ------------------------------------------------------------------\r
2870 \r
2871 TocParser::VarNameContext::VarNameContext(ParserRuleContext *parent, size_t invokingState)\r
2872   : ParserRuleContext(parent, invokingState) {\r
2873 }\r
2874 \r
2875 tree::TerminalNode* TocParser::VarNameContext::NAME() {\r
2876   return getToken(TocParser::NAME, 0);\r
2877 }\r
2878 \r
2879 \r
2880 size_t TocParser::VarNameContext::getRuleIndex() const {\r
2881   return TocParser::RuleVarName;\r
2882 }\r
2883 \r
2884 \r
2885 TocParser::VarNameContext* TocParser::varName() {\r
2886   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());\r
2887   enterRule(_localctx, 88, TocParser::RuleVarName);\r
2888 \r
2889 #if __cplusplus > 201703L\r
2890   auto onExit = finally([=, this] {\r
2891 #else\r
2892   auto onExit = finally([=] {\r
2893 #endif\r
2894     exitRule();\r
2895   });\r
2896   try {\r
2897     enterOuterAlt(_localctx, 1);\r
2898     setState(382);\r
2899     match(TocParser::NAME);\r
2900    \r
2901   }\r
2902   catch (RecognitionException &e) {\r
2903     _errHandler->reportError(this, e);\r
2904     _localctx->exception = std::current_exception();\r
2905     _errHandler->recover(this, _localctx->exception);\r
2906   }\r
2907 \r
2908   return _localctx;\r
2909 }\r
2910 \r
2911 //----------------- TypeNameContext ------------------------------------------------------------------\r
2912 \r
2913 TocParser::TypeNameContext::TypeNameContext(ParserRuleContext *parent, size_t invokingState)\r
2914   : ParserRuleContext(parent, invokingState) {\r
2915 }\r
2916 \r
2917 tree::TerminalNode* TocParser::TypeNameContext::NAME() {\r
2918   return getToken(TocParser::NAME, 0);\r
2919 }\r
2920 \r
2921 \r
2922 size_t TocParser::TypeNameContext::getRuleIndex() const {\r
2923   return TocParser::RuleTypeName;\r
2924 }\r
2925 \r
2926 \r
2927 TocParser::TypeNameContext* TocParser::typeName() {\r
2928   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());\r
2929   enterRule(_localctx, 90, TocParser::RuleTypeName);\r
2930 \r
2931 #if __cplusplus > 201703L\r
2932   auto onExit = finally([=, this] {\r
2933 #else\r
2934   auto onExit = finally([=] {\r
2935 #endif\r
2936     exitRule();\r
2937   });\r
2938   try {\r
2939     enterOuterAlt(_localctx, 1);\r
2940     setState(384);\r
2941     match(TocParser::NAME);\r
2942    \r
2943   }\r
2944   catch (RecognitionException &e) {\r
2945     _errHandler->reportError(this, e);\r
2946     _localctx->exception = std::current_exception();\r
2947     _errHandler->recover(this, _localctx->exception);\r
2948   }\r
2949 \r
2950   return _localctx;\r
2951 }\r
2952 \r
2953 //----------------- StructNameContext ------------------------------------------------------------------\r
2954 \r
2955 TocParser::StructNameContext::StructNameContext(ParserRuleContext *parent, size_t invokingState)\r
2956   : ParserRuleContext(parent, invokingState) {\r
2957 }\r
2958 \r
2959 tree::TerminalNode* TocParser::StructNameContext::NAME() {\r
2960   return getToken(TocParser::NAME, 0);\r
2961 }\r
2962 \r
2963 \r
2964 size_t TocParser::StructNameContext::getRuleIndex() const {\r
2965   return TocParser::RuleStructName;\r
2966 }\r
2967 \r
2968 \r
2969 TocParser::StructNameContext* TocParser::structName() {\r
2970   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());\r
2971   enterRule(_localctx, 92, TocParser::RuleStructName);\r
2972 \r
2973 #if __cplusplus > 201703L\r
2974   auto onExit = finally([=, this] {\r
2975 #else\r
2976   auto onExit = finally([=] {\r
2977 #endif\r
2978     exitRule();\r
2979   });\r
2980   try {\r
2981     enterOuterAlt(_localctx, 1);\r
2982     setState(386);\r
2983     match(TocParser::NAME);\r
2984    \r
2985   }\r
2986   catch (RecognitionException &e) {\r
2987     _errHandler->reportError(this, e);\r
2988     _localctx->exception = std::current_exception();\r
2989     _errHandler->recover(this, _localctx->exception);\r
2990   }\r
2991 \r
2992   return _localctx;\r
2993 }\r
2994 \r
2995 //----------------- Postfix_opContext ------------------------------------------------------------------\r
2996 \r
2997 TocParser::Postfix_opContext::Postfix_opContext(ParserRuleContext *parent, size_t invokingState)\r
2998   : ParserRuleContext(parent, invokingState) {\r
2999 }\r
3000 \r
3001 \r
3002 size_t TocParser::Postfix_opContext::getRuleIndex() const {\r
3003   return TocParser::RulePostfix_op;\r
3004 }\r
3005 \r
3006 \r
3007 TocParser::Postfix_opContext* TocParser::postfix_op() {\r
3008   Postfix_opContext *_localctx = _tracker.createInstance<Postfix_opContext>(_ctx, getState());\r
3009   enterRule(_localctx, 94, TocParser::RulePostfix_op);\r
3010   size_t _la = 0;\r
3011 \r
3012 #if __cplusplus > 201703L\r
3013   auto onExit = finally([=, this] {\r
3014 #else\r
3015   auto onExit = finally([=] {\r
3016 #endif\r
3017     exitRule();\r
3018   });\r
3019   try {\r
3020     enterOuterAlt(_localctx, 1);\r
3021     setState(388);\r
3022     _la = _input->LA(1);\r
3023     if (!(_la == TocParser::T__26\r
3024 \r
3025     || _la == TocParser::T__27)) {\r
3026     _errHandler->recoverInline(this);\r
3027     }\r
3028     else {\r
3029       _errHandler->reportMatch(this);\r
3030       consume();\r
3031     }\r
3032    \r
3033   }\r
3034   catch (RecognitionException &e) {\r
3035     _errHandler->reportError(this, e);\r
3036     _localctx->exception = std::current_exception();\r
3037     _errHandler->recover(this, _localctx->exception);\r
3038   }\r
3039 \r
3040   return _localctx;\r
3041 }\r
3042 \r
3043 //----------------- Prefix_opContext ------------------------------------------------------------------\r
3044 \r
3045 TocParser::Prefix_opContext::Prefix_opContext(ParserRuleContext *parent, size_t invokingState)\r
3046   : ParserRuleContext(parent, invokingState) {\r
3047 }\r
3048 \r
3049 TocParser::Postfix_opContext* TocParser::Prefix_opContext::postfix_op() {\r
3050   return getRuleContext<TocParser::Postfix_opContext>(0);\r
3051 }\r
3052 \r
3053 \r
3054 size_t TocParser::Prefix_opContext::getRuleIndex() const {\r
3055   return TocParser::RulePrefix_op;\r
3056 }\r
3057 \r
3058 \r
3059 TocParser::Prefix_opContext* TocParser::prefix_op() {\r
3060   Prefix_opContext *_localctx = _tracker.createInstance<Prefix_opContext>(_ctx, getState());\r
3061   enterRule(_localctx, 96, TocParser::RulePrefix_op);\r
3062 \r
3063 #if __cplusplus > 201703L\r
3064   auto onExit = finally([=, this] {\r
3065 #else\r
3066   auto onExit = finally([=] {\r
3067 #endif\r
3068     exitRule();\r
3069   });\r
3070   try {\r
3071     setState(397);\r
3072     _errHandler->sync(this);\r
3073     switch (_input->LA(1)) {\r
3074       case TocParser::T__28: {\r
3075         enterOuterAlt(_localctx, 1);\r
3076         setState(390);\r
3077         match(TocParser::T__28);\r
3078         break;\r
3079       }\r
3080 \r
3081       case TocParser::T__29: {\r
3082         enterOuterAlt(_localctx, 2);\r
3083         setState(391);\r
3084         match(TocParser::T__29);\r
3085         break;\r
3086       }\r
3087 \r
3088       case TocParser::T__30: {\r
3089         enterOuterAlt(_localctx, 3);\r
3090         setState(392);\r
3091         match(TocParser::T__30);\r
3092         break;\r
3093       }\r
3094 \r
3095       case TocParser::T__31: {\r
3096         enterOuterAlt(_localctx, 4);\r
3097         setState(393);\r
3098         match(TocParser::T__31);\r
3099         break;\r
3100       }\r
3101 \r
3102       case TocParser::T__32: {\r
3103         enterOuterAlt(_localctx, 5);\r
3104         setState(394);\r
3105         match(TocParser::T__32);\r
3106         break;\r
3107       }\r
3108 \r
3109       case TocParser::T__4: {\r
3110         enterOuterAlt(_localctx, 6);\r
3111         setState(395);\r
3112         match(TocParser::T__4);\r
3113         break;\r
3114       }\r
3115 \r
3116       case TocParser::T__26:\r
3117       case TocParser::T__27: {\r
3118         enterOuterAlt(_localctx, 7);\r
3119         setState(396);\r
3120         postfix_op();\r
3121         break;\r
3122       }\r
3123 \r
3124     default:\r
3125       throw NoViableAltException(this);\r
3126     }\r
3127    \r
3128   }\r
3129   catch (RecognitionException &e) {\r
3130     _errHandler->reportError(this, e);\r
3131     _localctx->exception = std::current_exception();\r
3132     _errHandler->recover(this, _localctx->exception);\r
3133   }\r
3134 \r
3135   return _localctx;\r
3136 }\r
3137 \r
3138 //----------------- Binary_opContext ------------------------------------------------------------------\r
3139 \r
3140 TocParser::Binary_opContext::Binary_opContext(ParserRuleContext *parent, size_t invokingState)\r
3141   : ParserRuleContext(parent, invokingState) {\r
3142 }\r
3143 \r
3144 \r
3145 size_t TocParser::Binary_opContext::getRuleIndex() const {\r
3146   return TocParser::RuleBinary_op;\r
3147 }\r
3148 \r
3149 \r
3150 TocParser::Binary_opContext* TocParser::binary_op() {\r
3151   Binary_opContext *_localctx = _tracker.createInstance<Binary_opContext>(_ctx, getState());\r
3152   enterRule(_localctx, 98, TocParser::RuleBinary_op);\r
3153   size_t _la = 0;\r
3154 \r
3155 #if __cplusplus > 201703L\r
3156   auto onExit = finally([=, this] {\r
3157 #else\r
3158   auto onExit = finally([=] {\r
3159 #endif\r
3160     exitRule();\r
3161   });\r
3162   try {\r
3163     enterOuterAlt(_localctx, 1);\r
3164     setState(399);\r
3165     _la = _input->LA(1);\r
3166     if (!((((_la & ~ 0x3fULL) == 0) &&\r
3167       ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
3168       | (1ULL << TocParser::T__14)\r
3169       | (1ULL << TocParser::T__15)\r
3170       | (1ULL << TocParser::T__28)\r
3171       | (1ULL << TocParser::T__29)\r
3172       | (1ULL << TocParser::T__32)\r
3173       | (1ULL << TocParser::T__33)\r
3174       | (1ULL << TocParser::T__34)\r
3175       | (1ULL << TocParser::T__35)\r
3176       | (1ULL << TocParser::T__36)\r
3177       | (1ULL << TocParser::T__37)\r
3178       | (1ULL << TocParser::T__38)\r
3179       | (1ULL << TocParser::T__39)\r
3180       | (1ULL << TocParser::T__40)\r
3181       | (1ULL << TocParser::T__41)\r
3182       | (1ULL << TocParser::T__42)\r
3183       | (1ULL << TocParser::T__43)\r
3184       | (1ULL << TocParser::T__44)\r
3185       | (1ULL << TocParser::T__45)\r
3186       | (1ULL << TocParser::T__46)\r
3187       | (1ULL << TocParser::T__47)\r
3188       | (1ULL << TocParser::T__48)\r
3189       | (1ULL << TocParser::T__49)\r
3190       | (1ULL << TocParser::T__50)\r
3191       | (1ULL << TocParser::T__51)\r
3192       | (1ULL << TocParser::T__52)\r
3193       | (1ULL << TocParser::T__53)\r
3194       | (1ULL << TocParser::T__54))) != 0))) {\r
3195     _errHandler->recoverInline(this);\r
3196     }\r
3197     else {\r
3198       _errHandler->reportMatch(this);\r
3199       consume();\r
3200     }\r
3201    \r
3202   }\r
3203   catch (RecognitionException &e) {\r
3204     _errHandler->reportError(this, e);\r
3205     _localctx->exception = std::current_exception();\r
3206     _errHandler->recover(this, _localctx->exception);\r
3207   }\r
3208 \r
3209   return _localctx;\r
3210 }\r
3211 \r
3212 // Static vars and initialization.\r
3213 std::vector<dfa::DFA> TocParser::_decisionToDFA;\r
3214 atn::PredictionContextCache TocParser::_sharedContextCache;\r
3215 \r
3216 // We own the ATN which in turn owns the ATN states.\r
3217 atn::ATN TocParser::_atn;\r
3218 std::vector<uint16_t> TocParser::_serializedATN;\r
3219 \r
3220 std::vector<std::string> TocParser::_ruleNames = {\r
3221   "prog", "decl", "varDecl", "var", "varInit", "type", "typeModifier", "funcDecl", \r
3222   "func", "parameter", "body", "structDecl", "structMember", "structVar", \r
3223   "structMethod", "genericDecl", "stmt", "ifStmt", "elseIfStmt", "elseStmt", \r
3224   "switchStmt", "switchBody", "switchCase", "forStmt", "whileStmt", "assignStmt", \r
3225   "returnStmt", "expr", "nonOpExpr", "nonAccessExpr", "funcExpr", "opExpr", \r
3226   "binaryOp", "prefixOp", "postfixOp", "ternaryOp", "identifierExpr", "litExpr", \r
3227   "accessExpr", "accessSubExpr", "accessMember", "accessBrackets", "parenExpr", \r
3228   "funcName", "varName", "typeName", "structName", "postfix_op", "prefix_op", \r
3229   "binary_op"\r
3230 };\r
3231 \r
3232 std::vector<std::string> TocParser::_literalNames = {\r
3233   "", "';'", "'var'", "':'", "'='", "'*'", "'['", "']'", "'func'", "'('", \r
3234   "')'", "','", "'{'", "'}'", "'struct'", "'<'", "'>'", "'if'", "'else'", \r
3235   "'switch'", "'case'", "'for'", "'while'", "'return'", "'\u003F'", "'.'", \r
3236   "'->'", "'++'", "'--'", "'+'", "'-'", "'!'", "'~'", "'&'", "'/'", "'%'", \r
3237   "'|'", "'^'", "'=='", "'!='", "'<='", "'>='", "'<<'", "'>>'", "'||'", \r
3238   "'&&'", "'&='", "'|='", "'^='", "'<<='", "'>>='", "'+='", "'-='", "'*='", \r
3239   "'/='", "'%='"\r
3240 };\r
3241 \r
3242 std::vector<std::string> TocParser::_symbolicNames = {\r
3243   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3244   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3245   "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
3246   "", "", "INT_LIT", "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", \r
3247   "NEWLINE"\r
3248 };\r
3249 \r
3250 dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);\r
3251 \r
3252 std::vector<std::string> TocParser::_tokenNames;\r
3253 \r
3254 TocParser::Initializer::Initializer() {\r
3255         for (size_t i = 0; i < _symbolicNames.size(); ++i) {\r
3256                 std::string name = _vocabulary.getLiteralName(i);\r
3257                 if (name.empty()) {\r
3258                         name = _vocabulary.getSymbolicName(i);\r
3259                 }\r
3260 \r
3261                 if (name.empty()) {\r
3262                         _tokenNames.push_back("<INVALID>");\r
3263                 } else {\r
3264       _tokenNames.push_back(name);\r
3265     }\r
3266         }\r
3267 \r
3268   static const uint16_t serializedATNSegment0[] = {\r
3269     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, \r
3270        0x3, 0x40, 0x194, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, \r
3271        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, \r
3272        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, \r
3273        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, \r
3274        0xe, 0x9, 0xe, 0x4, 0xf, 0x9, 0xf, 0x4, 0x10, 0x9, 0x10, 0x4, 0x11, \r
3275        0x9, 0x11, 0x4, 0x12, 0x9, 0x12, 0x4, 0x13, 0x9, 0x13, 0x4, 0x14, \r
3276        0x9, 0x14, 0x4, 0x15, 0x9, 0x15, 0x4, 0x16, 0x9, 0x16, 0x4, 0x17, \r
3277        0x9, 0x17, 0x4, 0x18, 0x9, 0x18, 0x4, 0x19, 0x9, 0x19, 0x4, 0x1a, \r
3278        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, \r
3279        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, \r
3280        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, \r
3281        0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, \r
3282        0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, \r
3283        0x9, 0x29, 0x4, 0x2a, 0x9, 0x2a, 0x4, 0x2b, 0x9, 0x2b, 0x4, 0x2c, \r
3284        0x9, 0x2c, 0x4, 0x2d, 0x9, 0x2d, 0x4, 0x2e, 0x9, 0x2e, 0x4, 0x2f, \r
3285        0x9, 0x2f, 0x4, 0x30, 0x9, 0x30, 0x4, 0x31, 0x9, 0x31, 0x4, 0x32, \r
3286        0x9, 0x32, 0x4, 0x33, 0x9, 0x33, 0x3, 0x2, 0x6, 0x2, 0x68, 0xa, 0x2, \r
3287        0xd, 0x2, 0xe, 0x2, 0x69, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, \r
3288        0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x73, 0xa, 0x3, 0x3, 0x4, \r
3289        0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, \r
3290        0x5, 0x3, 0x5, 0x5, 0x5, 0x7e, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 0x3, \r
3291        0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, \r
3292        0x7, 0x7, 0x89, 0xa, 0x7, 0xc, 0x7, 0xe, 0x7, 0x8c, 0xb, 0x7, 0x3, \r
3293        0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x91, 0xa, 0x8, 0x3, 0x8, 0x5, \r
3294        0x8, 0x94, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, 0x3, 0x9, 0x3, 0xa, 0x3, \r
3295        0xa, 0x5, 0xa, 0x9b, 0xa, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, \r
3296        0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, \r
3297        0x3, 0xb, 0x7, 0xb, 0xa8, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0xab, 0xb, \r
3298        0xb, 0x5, 0xb, 0xad, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0xb1, \r
3299        0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0xb4, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, \r
3300        0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x5, 0xd, 0xbb, 0xa, 0xd, 0x3, 0xd, \r
3301        0x3, 0xd, 0x7, 0xd, 0xbf, 0xa, 0xd, 0xc, 0xd, 0xe, 0xd, 0xc2, 0xb, \r
3302        0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, 0x5, 0xe, 0xc8, 0xa, \r
3303        0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 0x11, \r
3304        0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x7, 0x11, 0xd3, 0xa, 0x11, 0xc, \r
3305        0x11, 0xe, 0x11, 0xd6, 0xb, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, \r
3306        0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, \r
3307        0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, \r
3308        0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0xea, 0xa, 0x12, 0x3, \r
3309        0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x7, 0x13, 0xf0, 0xa, 0x13, \r
3310        0xc, 0x13, 0xe, 0x13, 0xf3, 0xb, 0x13, 0x3, 0x13, 0x5, 0x13, 0xf6, \r
3311        0xa, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, \r
3312        0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, \r
3313        0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x7, 0x17, 0x106, 0xa, 0x17, 0xc, \r
3314        0x17, 0xe, 0x17, 0x109, 0xb, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, \r
3315        0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, \r
3316        0x5, 0x19, 0x114, 0xa, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, \r
3317        0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, \r
3318        0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, \r
3319        0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, \r
3320        0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x12d, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, \r
3321        0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x5, 0x1e, 0x134, 0xa, 0x1e, 0x3, \r
3322        0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x5, 0x1f, 0x139, 0xa, 0x1f, 0x3, 0x20, \r
3323        0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x7, 0x20, 0x140, 0xa, \r
3324        0x20, 0xc, 0x20, 0xe, 0x20, 0x143, 0xb, 0x20, 0x5, 0x20, 0x145, 0xa, \r
3325        0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, \r
3326        0x21, 0x5, 0x21, 0x14d, 0xa, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x22, \r
3327        0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x7, 0x22, 0x155, 0xa, 0x22, 0xc, \r
3328        0x22, 0xe, 0x22, 0x158, 0xb, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x23, \r
3329        0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, \r
3330        0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x27, \r
3331        0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x6, 0x28, 0x16c, 0xa, 0x28, 0xd, \r
3332        0x28, 0xe, 0x28, 0x16d, 0x3, 0x29, 0x3, 0x29, 0x5, 0x29, 0x172, 0xa, \r
3333        0x29, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2a, 0x3, 0x2b, 0x3, 0x2b, 0x3, \r
3334        0x2b, 0x3, 0x2b, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, 0x2c, 0x3, \r
3335        0x2d, 0x3, 0x2d, 0x3, 0x2e, 0x3, 0x2e, 0x3, 0x2f, 0x3, 0x2f, 0x3, \r
3336        0x30, 0x3, 0x30, 0x3, 0x31, 0x3, 0x31, 0x3, 0x32, 0x3, 0x32, 0x3, \r
3337        0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x3, 0x32, 0x5, 0x32, 0x190, \r
3338        0xa, 0x32, 0x3, 0x33, 0x3, 0x33, 0x3, 0x33, 0x2, 0x2, 0x34, 0x2, \r
3339        0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, \r
3340        0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, \r
3341        0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, \r
3342        0x48, 0x4a, 0x4c, 0x4e, 0x50, 0x52, 0x54, 0x56, 0x58, 0x5a, 0x5c, \r
3343        0x5e, 0x60, 0x62, 0x64, 0x2, 0x6, 0x3, 0x2, 0x3a, 0x3d, 0x3, 0x2, \r
3344        0x1b, 0x1c, 0x3, 0x2, 0x1d, 0x1e, 0x6, 0x2, 0x7, 0x7, 0x11, 0x12, \r
3345        0x1f, 0x20, 0x23, 0x39, 0x2, 0x194, 0x2, 0x67, 0x3, 0x2, 0x2, 0x2, \r
3346        0x4, 0x72, 0x3, 0x2, 0x2, 0x2, 0x6, 0x74, 0x3, 0x2, 0x2, 0x2, 0x8, \r
3347        0x77, 0x3, 0x2, 0x2, 0x2, 0xa, 0x7f, 0x3, 0x2, 0x2, 0x2, 0xc, 0x86, \r
3348        0x3, 0x2, 0x2, 0x2, 0xe, 0x93, 0x3, 0x2, 0x2, 0x2, 0x10, 0x95, 0x3, \r
3349        0x2, 0x2, 0x2, 0x12, 0x98, 0x3, 0x2, 0x2, 0x2, 0x14, 0xac, 0x3, 0x2, \r
3350        0x2, 0x2, 0x16, 0xae, 0x3, 0x2, 0x2, 0x2, 0x18, 0xb7, 0x3, 0x2, 0x2, \r
3351        0x2, 0x1a, 0xc7, 0x3, 0x2, 0x2, 0x2, 0x1c, 0xc9, 0x3, 0x2, 0x2, 0x2, \r
3352        0x1e, 0xcc, 0x3, 0x2, 0x2, 0x2, 0x20, 0xce, 0x3, 0x2, 0x2, 0x2, 0x22, \r
3353        0xe9, 0x3, 0x2, 0x2, 0x2, 0x24, 0xeb, 0x3, 0x2, 0x2, 0x2, 0x26, 0xf7, \r
3354        0x3, 0x2, 0x2, 0x2, 0x28, 0xfc, 0x3, 0x2, 0x2, 0x2, 0x2a, 0xff, 0x3, \r
3355        0x2, 0x2, 0x2, 0x2c, 0x103, 0x3, 0x2, 0x2, 0x2, 0x2e, 0x10c, 0x3, \r
3356        0x2, 0x2, 0x2, 0x30, 0x110, 0x3, 0x2, 0x2, 0x2, 0x32, 0x11b, 0x3, \r
3357        0x2, 0x2, 0x2, 0x34, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x36, 0x123, 0x3, \r
3358        0x2, 0x2, 0x2, 0x38, 0x12c, 0x3, 0x2, 0x2, 0x2, 0x3a, 0x133, 0x3, \r
3359        0x2, 0x2, 0x2, 0x3c, 0x138, 0x3, 0x2, 0x2, 0x2, 0x3e, 0x13a, 0x3, \r
3360        0x2, 0x2, 0x2, 0x40, 0x14c, 0x3, 0x2, 0x2, 0x2, 0x42, 0x14e, 0x3, \r
3361        0x2, 0x2, 0x2, 0x44, 0x159, 0x3, 0x2, 0x2, 0x2, 0x46, 0x15c, 0x3, \r
3362        0x2, 0x2, 0x2, 0x48, 0x15f, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x165, 0x3, \r
3363        0x2, 0x2, 0x2, 0x4c, 0x167, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x169, 0x3, \r
3364        0x2, 0x2, 0x2, 0x50, 0x171, 0x3, 0x2, 0x2, 0x2, 0x52, 0x173, 0x3, \r
3365        0x2, 0x2, 0x2, 0x54, 0x176, 0x3, 0x2, 0x2, 0x2, 0x56, 0x17a, 0x3, \r
3366        0x2, 0x2, 0x2, 0x58, 0x17e, 0x3, 0x2, 0x2, 0x2, 0x5a, 0x180, 0x3, \r
3367        0x2, 0x2, 0x2, 0x5c, 0x182, 0x3, 0x2, 0x2, 0x2, 0x5e, 0x184, 0x3, \r
3368        0x2, 0x2, 0x2, 0x60, 0x186, 0x3, 0x2, 0x2, 0x2, 0x62, 0x18f, 0x3, \r
3369        0x2, 0x2, 0x2, 0x64, 0x191, 0x3, 0x2, 0x2, 0x2, 0x66, 0x68, 0x5, \r
3370        0x4, 0x3, 0x2, 0x67, 0x66, 0x3, 0x2, 0x2, 0x2, 0x68, 0x69, 0x3, 0x2, \r
3371        0x2, 0x2, 0x69, 0x67, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, 0x3, 0x2, 0x2, \r
3372        0x2, 0x6a, 0x6b, 0x3, 0x2, 0x2, 0x2, 0x6b, 0x6c, 0x7, 0x2, 0x2, 0x3, \r
3373        0x6c, 0x3, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x6, 0x4, 0x2, 0x6e, \r
3374        0x6f, 0x7, 0x3, 0x2, 0x2, 0x6f, 0x73, 0x3, 0x2, 0x2, 0x2, 0x70, 0x73, \r
3375        0x5, 0x10, 0x9, 0x2, 0x71, 0x73, 0x5, 0x18, 0xd, 0x2, 0x72, 0x6d, \r
3376        0x3, 0x2, 0x2, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, 0x72, 0x71, 0x3, \r
3377        0x2, 0x2, 0x2, 0x73, 0x5, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 0x7, 0x4, \r
3378        0x2, 0x2, 0x75, 0x76, 0x5, 0x8, 0x5, 0x2, 0x76, 0x7, 0x3, 0x2, 0x2, \r
3379        0x2, 0x77, 0x78, 0x5, 0x5a, 0x2e, 0x2, 0x78, 0x79, 0x7, 0x5, 0x2, \r
3380        0x2, 0x79, 0x7a, 0x5, 0xc, 0x7, 0x2, 0x7a, 0x7d, 0x3, 0x2, 0x2, 0x2, \r
3381        0x7b, 0x7c, 0x7, 0x6, 0x2, 0x2, 0x7c, 0x7e, 0x5, 0x38, 0x1d, 0x2, \r
3382        0x7d, 0x7b, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, \r
3383        0x9, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x80, 0x5, 0x5a, 0x2e, 0x2, 0x80, \r
3384        0x81, 0x7, 0x5, 0x2, 0x2, 0x81, 0x82, 0x5, 0xc, 0x7, 0x2, 0x82, 0x83, \r
3385        0x3, 0x2, 0x2, 0x2, 0x83, 0x84, 0x7, 0x6, 0x2, 0x2, 0x84, 0x85, 0x5, \r
3386        0x38, 0x1d, 0x2, 0x85, 0xb, 0x3, 0x2, 0x2, 0x2, 0x86, 0x8a, 0x5, \r
3387        0x5c, 0x2f, 0x2, 0x87, 0x89, 0x5, 0xe, 0x8, 0x2, 0x88, 0x87, 0x3, \r
3388        0x2, 0x2, 0x2, 0x89, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, \r
3389        0x2, 0x2, 0x8a, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8b, 0xd, 0x3, 0x2, 0x2, \r
3390        0x2, 0x8c, 0x8a, 0x3, 0x2, 0x2, 0x2, 0x8d, 0x94, 0x7, 0x7, 0x2, 0x2, \r
3391        0x8e, 0x90, 0x7, 0x8, 0x2, 0x2, 0x8f, 0x91, 0x7, 0x3a, 0x2, 0x2, \r
3392        0x90, 0x8f, 0x3, 0x2, 0x2, 0x2, 0x90, 0x91, 0x3, 0x2, 0x2, 0x2, 0x91, \r
3393        0x92, 0x3, 0x2, 0x2, 0x2, 0x92, 0x94, 0x7, 0x9, 0x2, 0x2, 0x93, 0x8d, \r
3394        0x3, 0x2, 0x2, 0x2, 0x93, 0x8e, 0x3, 0x2, 0x2, 0x2, 0x94, 0xf, 0x3, \r
3395        0x2, 0x2, 0x2, 0x95, 0x96, 0x7, 0xa, 0x2, 0x2, 0x96, 0x97, 0x5, 0x12, \r
3396        0xa, 0x2, 0x97, 0x11, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9a, 0x5, 0x58, \r
3397        0x2d, 0x2, 0x99, 0x9b, 0x5, 0x20, 0x11, 0x2, 0x9a, 0x99, 0x3, 0x2, \r
3398        0x2, 0x2, 0x9a, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9c, 0x3, 0x2, 0x2, \r
3399        0x2, 0x9c, 0x9d, 0x7, 0xb, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x14, 0xb, \r
3400        0x2, 0x9e, 0x9f, 0x7, 0xc, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0x5, 0x2, 0x2, \r
3401        0xa0, 0xa1, 0x5, 0xc, 0x7, 0x2, 0xa1, 0xa2, 0x3, 0x2, 0x2, 0x2, 0xa2, \r
3402        0xa3, 0x5, 0x16, 0xc, 0x2, 0xa3, 0x13, 0x3, 0x2, 0x2, 0x2, 0xa4, \r
3403        0xa9, 0x5, 0x8, 0x5, 0x2, 0xa5, 0xa6, 0x7, 0xd, 0x2, 0x2, 0xa6, 0xa8, \r
3404        0x5, 0x8, 0x5, 0x2, 0xa7, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa8, 0xab, 0x3, \r
3405        0x2, 0x2, 0x2, 0xa9, 0xa7, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x3, 0x2, \r
3406        0x2, 0x2, 0xaa, 0xad, 0x3, 0x2, 0x2, 0x2, 0xab, 0xa9, 0x3, 0x2, 0x2, \r
3407        0x2, 0xac, 0xa4, 0x3, 0x2, 0x2, 0x2, 0xac, 0xad, 0x3, 0x2, 0x2, 0x2, \r
3408        0xad, 0x15, 0x3, 0x2, 0x2, 0x2, 0xae, 0xb2, 0x7, 0xe, 0x2, 0x2, 0xaf, \r
3409        0xb1, 0x5, 0x22, 0x12, 0x2, 0xb0, 0xaf, 0x3, 0x2, 0x2, 0x2, 0xb1, \r
3410        0xb4, 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb2, 0xb3, \r
3411        0x3, 0x2, 0x2, 0x2, 0xb3, 0xb5, 0x3, 0x2, 0x2, 0x2, 0xb4, 0xb2, 0x3, \r
3412        0x2, 0x2, 0x2, 0xb5, 0xb6, 0x7, 0xf, 0x2, 0x2, 0xb6, 0x17, 0x3, 0x2, \r
3413        0x2, 0x2, 0xb7, 0xb8, 0x7, 0x10, 0x2, 0x2, 0xb8, 0xba, 0x5, 0x5e, \r
3414        0x30, 0x2, 0xb9, 0xbb, 0x5, 0x20, 0x11, 0x2, 0xba, 0xb9, 0x3, 0x2, \r
3415        0x2, 0x2, 0xba, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbb, 0xbc, 0x3, 0x2, 0x2, \r
3416        0x2, 0xbc, 0xc0, 0x7, 0xe, 0x2, 0x2, 0xbd, 0xbf, 0x5, 0x1a, 0xe, \r
3417        0x2, 0xbe, 0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc2, 0x3, 0x2, 0x2, 0x2, \r
3418        0xc0, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc1, \r
3419        0xc3, 0x3, 0x2, 0x2, 0x2, 0xc2, 0xc0, 0x3, 0x2, 0x2, 0x2, 0xc3, 0xc4, \r
3420        0x7, 0xf, 0x2, 0x2, 0xc4, 0x19, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc8, 0x5, \r
3421        0x1c, 0xf, 0x2, 0xc6, 0xc8, 0x5, 0x1e, 0x10, 0x2, 0xc7, 0xc5, 0x3, \r
3422        0x2, 0x2, 0x2, 0xc7, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc8, 0x1b, 0x3, 0x2, \r
3423        0x2, 0x2, 0xc9, 0xca, 0x5, 0x8, 0x5, 0x2, 0xca, 0xcb, 0x7, 0x3, 0x2, \r
3424        0x2, 0xcb, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xcc, 0xcd, 0x5, 0x12, 0xa, \r
3425        0x2, 0xcd, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcf, 0x7, 0x11, 0x2, \r
3426        0x2, 0xcf, 0xd4, 0x5, 0x5c, 0x2f, 0x2, 0xd0, 0xd1, 0x7, 0xd, 0x2, \r
3427        0x2, 0xd1, 0xd3, 0x5, 0x5c, 0x2f, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, \r
3428        0x2, 0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, \r
3429        0xd4, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd7, 0x3, 0x2, 0x2, 0x2, 0xd6, \r
3430        0xd4, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x7, 0x12, 0x2, 0x2, 0xd8, \r
3431        0x21, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x5, 0x6, 0x4, 0x2, 0xda, 0xdb, \r
3432        0x7, 0x3, 0x2, 0x2, 0xdb, 0xea, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xea, 0x5, \r
3433        0x24, 0x13, 0x2, 0xdd, 0xea, 0x5, 0x2a, 0x16, 0x2, 0xde, 0xea, 0x5, \r
3434        0x30, 0x19, 0x2, 0xdf, 0xea, 0x5, 0x32, 0x1a, 0x2, 0xe0, 0xe1, 0x5, \r
3435        0x34, 0x1b, 0x2, 0xe1, 0xe2, 0x7, 0x3, 0x2, 0x2, 0xe2, 0xea, 0x3, \r
3436        0x2, 0x2, 0x2, 0xe3, 0xe4, 0x5, 0x36, 0x1c, 0x2, 0xe4, 0xe5, 0x7, \r
3437        0x3, 0x2, 0x2, 0xe5, 0xea, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe7, 0x5, 0x38, \r
3438        0x1d, 0x2, 0xe7, 0xe8, 0x7, 0x3, 0x2, 0x2, 0xe8, 0xea, 0x3, 0x2, \r
3439        0x2, 0x2, 0xe9, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xdc, 0x3, 0x2, 0x2, \r
3440        0x2, 0xe9, 0xdd, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xde, 0x3, 0x2, 0x2, 0x2, \r
3441        0xe9, 0xdf, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe9, \r
3442        0xe3, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe6, 0x3, 0x2, 0x2, 0x2, 0xea, 0x23, \r
3443        0x3, 0x2, 0x2, 0x2, 0xeb, 0xec, 0x7, 0x13, 0x2, 0x2, 0xec, 0xed, \r
3444        0x5, 0x38, 0x1d, 0x2, 0xed, 0xf1, 0x5, 0x16, 0xc, 0x2, 0xee, 0xf0, \r
3445        0x5, 0x26, 0x14, 0x2, 0xef, 0xee, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf3, \r
3446        0x3, 0x2, 0x2, 0x2, 0xf1, 0xef, 0x3, 0x2, 0x2, 0x2, 0xf1, 0xf2, 0x3, \r
3447        0x2, 0x2, 0x2, 0xf2, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xf3, 0xf1, 0x3, 0x2, \r
3448        0x2, 0x2, 0xf4, 0xf6, 0x5, 0x28, 0x15, 0x2, 0xf5, 0xf4, 0x3, 0x2, \r
3449        0x2, 0x2, 0xf5, 0xf6, 0x3, 0x2, 0x2, 0x2, 0xf6, 0x25, 0x3, 0x2, 0x2, \r
3450        0x2, 0xf7, 0xf8, 0x7, 0x14, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x13, 0x2, \r
3451        0x2, 0xf9, 0xfa, 0x5, 0x38, 0x1d, 0x2, 0xfa, 0xfb, 0x5, 0x16, 0xc, \r
3452        0x2, 0xfb, 0x27, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x14, 0x2, \r
3453        0x2, 0xfd, 0xfe, 0x5, 0x16, 0xc, 0x2, 0xfe, 0x29, 0x3, 0x2, 0x2, \r
3454        0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x101, 0x5, 0x4a, 0x26, \r
3455        0x2, 0x101, 0x102, 0x5, 0x2c, 0x17, 0x2, 0x102, 0x2b, 0x3, 0x2, 0x2, \r
3456        0x2, 0x103, 0x107, 0x7, 0xe, 0x2, 0x2, 0x104, 0x106, 0x5, 0x2e, 0x18, \r
3457        0x2, 0x105, 0x104, 0x3, 0x2, 0x2, 0x2, 0x106, 0x109, 0x3, 0x2, 0x2, \r
3458        0x2, 0x107, 0x105, 0x3, 0x2, 0x2, 0x2, 0x107, 0x108, 0x3, 0x2, 0x2, \r
3459        0x2, 0x108, 0x10a, 0x3, 0x2, 0x2, 0x2, 0x109, 0x107, 0x3, 0x2, 0x2, \r
3460        0x2, 0x10a, 0x10b, 0x7, 0xf, 0x2, 0x2, 0x10b, 0x2d, 0x3, 0x2, 0x2, \r
3461        0x2, 0x10c, 0x10d, 0x7, 0x16, 0x2, 0x2, 0x10d, 0x10e, 0x5, 0x38, \r
3462        0x1d, 0x2, 0x10e, 0x10f, 0x5, 0x16, 0xc, 0x2, 0x10f, 0x2f, 0x3, 0x2, \r
3463        0x2, 0x2, 0x110, 0x113, 0x7, 0x17, 0x2, 0x2, 0x111, 0x114, 0x5, 0xa, \r
3464        0x6, 0x2, 0x112, 0x114, 0x5, 0x34, 0x1b, 0x2, 0x113, 0x111, 0x3, \r
3465        0x2, 0x2, 0x2, 0x113, 0x112, 0x3, 0x2, 0x2, 0x2, 0x114, 0x115, 0x3, \r
3466        0x2, 0x2, 0x2, 0x115, 0x116, 0x7, 0xd, 0x2, 0x2, 0x116, 0x117, 0x5, \r
3467        0x38, 0x1d, 0x2, 0x117, 0x118, 0x7, 0xd, 0x2, 0x2, 0x118, 0x119, \r
3468        0x5, 0x38, 0x1d, 0x2, 0x119, 0x11a, 0x5, 0x16, 0xc, 0x2, 0x11a, 0x31, \r
3469        0x3, 0x2, 0x2, 0x2, 0x11b, 0x11c, 0x7, 0x18, 0x2, 0x2, 0x11c, 0x11d, \r
3470        0x5, 0x38, 0x1d, 0x2, 0x11d, 0x11e, 0x5, 0x16, 0xc, 0x2, 0x11e, 0x33, \r
3471        0x3, 0x2, 0x2, 0x2, 0x11f, 0x120, 0x5, 0x4a, 0x26, 0x2, 0x120, 0x121, \r
3472        0x7, 0x6, 0x2, 0x2, 0x121, 0x122, 0x5, 0x38, 0x1d, 0x2, 0x122, 0x35, \r
3473        0x3, 0x2, 0x2, 0x2, 0x123, 0x124, 0x7, 0x19, 0x2, 0x2, 0x124, 0x125, \r
3474        0x5, 0x38, 0x1d, 0x2, 0x125, 0x37, 0x3, 0x2, 0x2, 0x2, 0x126, 0x12d, \r
3475        0x5, 0x3e, 0x20, 0x2, 0x127, 0x12d, 0x5, 0x4c, 0x27, 0x2, 0x128, \r
3476        0x12d, 0x5, 0x4a, 0x26, 0x2, 0x129, 0x12d, 0x5, 0x56, 0x2c, 0x2, \r
3477        0x12a, 0x12d, 0x5, 0x4e, 0x28, 0x2, 0x12b, 0x12d, 0x5, 0x40, 0x21, \r
3478        0x2, 0x12c, 0x126, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x127, 0x3, 0x2, 0x2, \r
3479        0x2, 0x12c, 0x128, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x129, 0x3, 0x2, 0x2, \r
3480        0x2, 0x12c, 0x12a, 0x3, 0x2, 0x2, 0x2, 0x12c, 0x12b, 0x3, 0x2, 0x2, \r
3481        0x2, 0x12d, 0x39, 0x3, 0x2, 0x2, 0x2, 0x12e, 0x134, 0x5, 0x3e, 0x20, \r
3482        0x2, 0x12f, 0x134, 0x5, 0x4c, 0x27, 0x2, 0x130, 0x134, 0x5, 0x4a, \r
3483        0x26, 0x2, 0x131, 0x134, 0x5, 0x56, 0x2c, 0x2, 0x132, 0x134, 0x5, \r
3484        0x4e, 0x28, 0x2, 0x133, 0x12e, 0x3, 0x2, 0x2, 0x2, 0x133, 0x12f, \r
3485        0x3, 0x2, 0x2, 0x2, 0x133, 0x130, 0x3, 0x2, 0x2, 0x2, 0x133, 0x131, \r
3486        0x3, 0x2, 0x2, 0x2, 0x133, 0x132, 0x3, 0x2, 0x2, 0x2, 0x134, 0x3b, \r
3487        0x3, 0x2, 0x2, 0x2, 0x135, 0x139, 0x5, 0x3e, 0x20, 0x2, 0x136, 0x139, \r
3488        0x5, 0x4a, 0x26, 0x2, 0x137, 0x139, 0x5, 0x56, 0x2c, 0x2, 0x138, \r
3489        0x135, 0x3, 0x2, 0x2, 0x2, 0x138, 0x136, 0x3, 0x2, 0x2, 0x2, 0x138, \r
3490        0x137, 0x3, 0x2, 0x2, 0x2, 0x139, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x13a, \r
3491        0x13b, 0x5, 0x58, 0x2d, 0x2, 0x13b, 0x144, 0x7, 0xb, 0x2, 0x2, 0x13c, \r
3492        0x141, 0x5, 0x38, 0x1d, 0x2, 0x13d, 0x13e, 0x7, 0xd, 0x2, 0x2, 0x13e, \r
3493        0x140, 0x5, 0x38, 0x1d, 0x2, 0x13f, 0x13d, 0x3, 0x2, 0x2, 0x2, 0x140, \r
3494        0x143, 0x3, 0x2, 0x2, 0x2, 0x141, 0x13f, 0x3, 0x2, 0x2, 0x2, 0x141, \r
3495        0x142, 0x3, 0x2, 0x2, 0x2, 0x142, 0x145, 0x3, 0x2, 0x2, 0x2, 0x143, \r
3496        0x141, 0x3, 0x2, 0x2, 0x2, 0x144, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x144, \r
3497        0x145, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, 0x3, 0x2, 0x2, 0x2, 0x146, \r
3498        0x147, 0x7, 0xc, 0x2, 0x2, 0x147, 0x3f, 0x3, 0x2, 0x2, 0x2, 0x148, \r
3499        0x14d, 0x5, 0x42, 0x22, 0x2, 0x149, 0x14d, 0x5, 0x44, 0x23, 0x2, \r
3500        0x14a, 0x14d, 0x5, 0x46, 0x24, 0x2, 0x14b, 0x14d, 0x5, 0x48, 0x25, \r
3501        0x2, 0x14c, 0x148, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x149, 0x3, 0x2, 0x2, \r
3502        0x2, 0x14c, 0x14a, 0x3, 0x2, 0x2, 0x2, 0x14c, 0x14b, 0x3, 0x2, 0x2, \r
3503        0x2, 0x14d, 0x41, 0x3, 0x2, 0x2, 0x2, 0x14e, 0x14f, 0x5, 0x3a, 0x1e, \r
3504        0x2, 0x14f, 0x150, 0x5, 0x64, 0x33, 0x2, 0x150, 0x156, 0x5, 0x3a, \r
3505        0x1e, 0x2, 0x151, 0x152, 0x5, 0x64, 0x33, 0x2, 0x152, 0x153, 0x5, \r
3506        0x3a, 0x1e, 0x2, 0x153, 0x155, 0x3, 0x2, 0x2, 0x2, 0x154, 0x151, \r
3507        0x3, 0x2, 0x2, 0x2, 0x155, 0x158, 0x3, 0x2, 0x2, 0x2, 0x156, 0x154, \r
3508        0x3, 0x2, 0x2, 0x2, 0x156, 0x157, 0x3, 0x2, 0x2, 0x2, 0x157, 0x43, \r
3509        0x3, 0x2, 0x2, 0x2, 0x158, 0x156, 0x3, 0x2, 0x2, 0x2, 0x159, 0x15a, \r
3510        0x5, 0x62, 0x32, 0x2, 0x15a, 0x15b, 0x5, 0x3a, 0x1e, 0x2, 0x15b, \r
3511        0x45, 0x3, 0x2, 0x2, 0x2, 0x15c, 0x15d, 0x5, 0x3a, 0x1e, 0x2, 0x15d, \r
3512        0x15e, 0x5, 0x60, 0x31, 0x2, 0x15e, 0x47, 0x3, 0x2, 0x2, 0x2, 0x15f, \r
3513        0x160, 0x5, 0x3a, 0x1e, 0x2, 0x160, 0x161, 0x7, 0x1a, 0x2, 0x2, 0x161, \r
3514        0x162, 0x5, 0x38, 0x1d, 0x2, 0x162, 0x163, 0x7, 0x5, 0x2, 0x2, 0x163, \r
3515        0x164, 0x5, 0x38, 0x1d, 0x2, 0x164, 0x49, 0x3, 0x2, 0x2, 0x2, 0x165, \r
3516        0x166, 0x5, 0x5a, 0x2e, 0x2, 0x166, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x167, \r
3517        0x168, 0x9, 0x2, 0x2, 0x2, 0x168, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x169, \r
3518        0x16b, 0x5, 0x3c, 0x1f, 0x2, 0x16a, 0x16c, 0x5, 0x50, 0x29, 0x2, \r
3519        0x16b, 0x16a, 0x3, 0x2, 0x2, 0x2, 0x16c, 0x16d, 0x3, 0x2, 0x2, 0x2, \r
3520        0x16d, 0x16b, 0x3, 0x2, 0x2, 0x2, 0x16d, 0x16e, 0x3, 0x2, 0x2, 0x2, \r
3521        0x16e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x16f, 0x172, 0x5, 0x52, 0x2a, 0x2, \r
3522        0x170, 0x172, 0x5, 0x54, 0x2b, 0x2, 0x171, 0x16f, 0x3, 0x2, 0x2, \r
3523        0x2, 0x171, 0x170, 0x3, 0x2, 0x2, 0x2, 0x172, 0x51, 0x3, 0x2, 0x2, \r
3524        0x2, 0x173, 0x174, 0x9, 0x3, 0x2, 0x2, 0x174, 0x175, 0x5, 0x4a, 0x26, \r
3525        0x2, 0x175, 0x53, 0x3, 0x2, 0x2, 0x2, 0x176, 0x177, 0x7, 0x8, 0x2, \r
3526        0x2, 0x177, 0x178, 0x5, 0x38, 0x1d, 0x2, 0x178, 0x179, 0x7, 0x9, \r
3527        0x2, 0x2, 0x179, 0x55, 0x3, 0x2, 0x2, 0x2, 0x17a, 0x17b, 0x7, 0xb, \r
3528        0x2, 0x2, 0x17b, 0x17c, 0x5, 0x38, 0x1d, 0x2, 0x17c, 0x17d, 0x7, \r
3529        0xc, 0x2, 0x2, 0x17d, 0x57, 0x3, 0x2, 0x2, 0x2, 0x17e, 0x17f, 0x7, \r
3530        0x3e, 0x2, 0x2, 0x17f, 0x59, 0x3, 0x2, 0x2, 0x2, 0x180, 0x181, 0x7, \r
3531        0x3e, 0x2, 0x2, 0x181, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x182, 0x183, 0x7, \r
3532        0x3e, 0x2, 0x2, 0x183, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x184, 0x185, 0x7, \r
3533        0x3e, 0x2, 0x2, 0x185, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x186, 0x187, 0x9, \r
3534        0x4, 0x2, 0x2, 0x187, 0x61, 0x3, 0x2, 0x2, 0x2, 0x188, 0x190, 0x7, \r
3535        0x1f, 0x2, 0x2, 0x189, 0x190, 0x7, 0x20, 0x2, 0x2, 0x18a, 0x190, \r
3536        0x7, 0x21, 0x2, 0x2, 0x18b, 0x190, 0x7, 0x22, 0x2, 0x2, 0x18c, 0x190, \r
3537        0x7, 0x23, 0x2, 0x2, 0x18d, 0x190, 0x7, 0x7, 0x2, 0x2, 0x18e, 0x190, \r
3538        0x5, 0x60, 0x31, 0x2, 0x18f, 0x188, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x189, \r
3539        0x3, 0x2, 0x2, 0x2, 0x18f, 0x18a, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18b, \r
3540        0x3, 0x2, 0x2, 0x2, 0x18f, 0x18c, 0x3, 0x2, 0x2, 0x2, 0x18f, 0x18d, \r
3541        0x3, 0x2, 0x2, 0x2, 0x18f, 0x18e, 0x3, 0x2, 0x2, 0x2, 0x190, 0x63, \r
3542        0x3, 0x2, 0x2, 0x2, 0x191, 0x192, 0x9, 0x5, 0x2, 0x2, 0x192, 0x65, \r
3543        0x3, 0x2, 0x2, 0x2, 0x1f, 0x69, 0x72, 0x7d, 0x8a, 0x90, 0x93, 0x9a, \r
3544        0xa9, 0xac, 0xb2, 0xba, 0xc0, 0xc7, 0xd4, 0xe9, 0xf1, 0xf5, 0x107, \r
3545        0x113, 0x12c, 0x133, 0x138, 0x141, 0x144, 0x14c, 0x156, 0x16d, 0x171, \r
3546        0x18f, \r
3547   };\r
3548 \r
3549   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,\r
3550     serializedATNSegment0 + sizeof(serializedATNSegment0) / sizeof(serializedATNSegment0[0]));\r
3551 \r
3552 \r
3553   atn::ATNDeserializer deserializer;\r
3554   _atn = deserializer.deserialize(_serializedATN);\r
3555 \r
3556   size_t count = _atn.getNumberOfDecisions();\r
3557   _decisionToDFA.reserve(count);\r
3558   for (size_t i = 0; i < count; i++) { \r
3559     _decisionToDFA.emplace_back(_atn.getDecisionState(i), i);\r
3560   }\r
3561 }\r
3562 \r
3563 TocParser::Initializer TocParser::_init;\r