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