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