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