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