toc now uses internal representation instead of ast

1 files changed, 453 insertions, 430 deletions

diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp
index 8c58634..eb6928d 100644
--- a/gen/TocParser.cpp
+++ b/gen/TocParser.cpp
@@ -80,20 +80,20 @@ TocParser::ProgContext* TocParser::prog() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(75); 

+    setState(73); 

     _errHandler->sync(this);

     _la = _input->LA(1);

     do {

-      setState(74);

+      setState(72);

       decl();

-      setState(77); 

+      setState(75); 

       _errHandler->sync(this);

       _la = _input->LA(1);

     } while ((((_la & ~ 0x3fULL) == 0) &&

       ((1ULL << _la) & ((1ULL << TocParser::T__0)

       | (1ULL << TocParser::T__3)

       | (1ULL << TocParser::T__9))) != 0));

-    setState(79);

+    setState(77);

     match(TocParser::EOF);

    

   }

@@ -153,26 +153,26 @@ TocParser::DeclContext* TocParser::decl() {
     exitRule();

   });

   try {

-    setState(84);

+    setState(82);

     _errHandler->sync(this);

     switch (_input->LA(1)) {

       case TocParser::T__0: {

         enterOuterAlt(_localctx, 1);

-        setState(81);

+        setState(79);

         varDecl();

         break;

       }

 

       case TocParser::T__3: {

         enterOuterAlt(_localctx, 2);

-        setState(82);

+        setState(80);

         funcDecl();

         break;

       }

 

       case TocParser::T__9: {

         enterOuterAlt(_localctx, 3);

-        setState(83);

+        setState(81);

         structDecl();

         break;

       }

@@ -231,9 +231,9 @@ TocParser::VarDeclContext* TocParser::varDecl() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(86);

+    setState(84);

     match(TocParser::T__0);

-    setState(87);

+    setState(85);

     var();

    

   }

@@ -295,21 +295,21 @@ TocParser::VarContext* TocParser::var() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(89);

+    setState(87);

     varName();

 

-    setState(90);

+    setState(88);

     match(TocParser::T__1);

-    setState(91);

+    setState(89);

     type();

-    setState(95);

+    setState(93);

     _errHandler->sync(this);

 

     _la = _input->LA(1);

     if (_la == TocParser::T__2) {

-      setState(93);

+      setState(91);

       match(TocParser::T__2);

-      setState(94);

+      setState(92);

       expr();

     }

    

@@ -363,7 +363,7 @@ TocParser::TypeContext* TocParser::type() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(97);

+    setState(95);

     typeName();

    

   }

@@ -416,9 +416,9 @@ TocParser::FuncDeclContext* TocParser::funcDecl() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(99);

+    setState(97);

     match(TocParser::T__3);

-    setState(100);

+    setState(98);

     func();

    

   }

@@ -483,20 +483,20 @@ TocParser::FuncContext* TocParser::func() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(102);

+    setState(100);

     funcName();

-    setState(103);

+    setState(101);

     match(TocParser::T__4);

-    setState(104);

+    setState(102);

     parameter();

-    setState(105);

+    setState(103);

     match(TocParser::T__5);

 

-    setState(106);

+    setState(104);

     match(TocParser::T__1);

-    setState(107);

+    setState(105);

     type();

-    setState(109);

+    setState(107);

     body();

    

   }

@@ -515,16 +515,12 @@ TocParser::ParameterContext::ParameterContext(ParserRuleContext *parent, size_t
   : ParserRuleContext(parent, invokingState) {

 }

 

-TocParser::FirstParameterContext* TocParser::ParameterContext::firstParameter() {

-  return getRuleContext<TocParser::FirstParameterContext>(0);

-}

-

-std::vector<TocParser::AdditionalParameterContext *> TocParser::ParameterContext::additionalParameter() {

-  return getRuleContexts<TocParser::AdditionalParameterContext>();

+std::vector<TocParser::VarContext *> TocParser::ParameterContext::var() {

+  return getRuleContexts<TocParser::VarContext>();

 }

 

-TocParser::AdditionalParameterContext* TocParser::ParameterContext::additionalParameter(size_t i) {

-  return getRuleContext<TocParser::AdditionalParameterContext>(i);

+TocParser::VarContext* TocParser::ParameterContext::var(size_t i) {

+  return getRuleContext<TocParser::VarContext>(i);

 }

 

 

@@ -558,20 +554,22 @@ TocParser::ParameterContext* TocParser::parameter() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(118);

+    setState(117);

     _errHandler->sync(this);

 

     _la = _input->LA(1);

     if (_la == TocParser::NAME) {

-      setState(111);

-      firstParameter();

-      setState(115);

+      setState(109);

+      var();

+      setState(114);

       _errHandler->sync(this);

       _la = _input->LA(1);

       while (_la == TocParser::T__6) {

-        setState(112);

-        additionalParameter();

-        setState(117);

+        setState(110);

+        match(TocParser::T__6);

+        setState(111);

+        var();

+        setState(116);

         _errHandler->sync(this);

         _la = _input->LA(1);

       }

@@ -587,114 +585,6 @@ TocParser::ParameterContext* TocParser::parameter() {
   return _localctx;

 }

 

-//----------------- FirstParameterContext ------------------------------------------------------------------

-

-TocParser::FirstParameterContext::FirstParameterContext(ParserRuleContext *parent, size_t invokingState)

-  : ParserRuleContext(parent, invokingState) {

-}

-

-TocParser::VarContext* TocParser::FirstParameterContext::var() {

-  return getRuleContext<TocParser::VarContext>(0);

-}

-

-

-size_t TocParser::FirstParameterContext::getRuleIndex() const {

-  return TocParser::RuleFirstParameter;

-}

-

-void TocParser::FirstParameterContext::enterRule(tree::ParseTreeListener *listener) {

-  auto parserListener = dynamic_cast<TocListener *>(listener);

-  if (parserListener != nullptr)

-    parserListener->enterFirstParameter(this);

-}

-

-void TocParser::FirstParameterContext::exitRule(tree::ParseTreeListener *listener) {

-  auto parserListener = dynamic_cast<TocListener *>(listener);

-  if (parserListener != nullptr)

-    parserListener->exitFirstParameter(this);

-}

-

-TocParser::FirstParameterContext* TocParser::firstParameter() {

-  FirstParameterContext *_localctx = _tracker.createInstance<FirstParameterContext>(_ctx, getState());

-  enterRule(_localctx, 16, TocParser::RuleFirstParameter);

-

-#if __cplusplus > 201703L

-  auto onExit = finally([=, this] {

-#else

-  auto onExit = finally([=] {

-#endif

-    exitRule();

-  });

-  try {

-    enterOuterAlt(_localctx, 1);

-    setState(120);

-    var();

-   

-  }

-  catch (RecognitionException &e) {

-    _errHandler->reportError(this, e);

-    _localctx->exception = std::current_exception();

-    _errHandler->recover(this, _localctx->exception);

-  }

-

-  return _localctx;

-}

-

-//----------------- AdditionalParameterContext ------------------------------------------------------------------

-

-TocParser::AdditionalParameterContext::AdditionalParameterContext(ParserRuleContext *parent, size_t invokingState)

-  : ParserRuleContext(parent, invokingState) {

-}

-

-TocParser::VarContext* TocParser::AdditionalParameterContext::var() {

-  return getRuleContext<TocParser::VarContext>(0);

-}

-

-

-size_t TocParser::AdditionalParameterContext::getRuleIndex() const {

-  return TocParser::RuleAdditionalParameter;

-}

-

-void TocParser::AdditionalParameterContext::enterRule(tree::ParseTreeListener *listener) {

-  auto parserListener = dynamic_cast<TocListener *>(listener);

-  if (parserListener != nullptr)

-    parserListener->enterAdditionalParameter(this);

-}

-

-void TocParser::AdditionalParameterContext::exitRule(tree::ParseTreeListener *listener) {

-  auto parserListener = dynamic_cast<TocListener *>(listener);

-  if (parserListener != nullptr)

-    parserListener->exitAdditionalParameter(this);

-}

-

-TocParser::AdditionalParameterContext* TocParser::additionalParameter() {

-  AdditionalParameterContext *_localctx = _tracker.createInstance<AdditionalParameterContext>(_ctx, getState());

-  enterRule(_localctx, 18, TocParser::RuleAdditionalParameter);

-

-#if __cplusplus > 201703L

-  auto onExit = finally([=, this] {

-#else

-  auto onExit = finally([=] {

-#endif

-    exitRule();

-  });

-  try {

-    enterOuterAlt(_localctx, 1);

-    setState(122);

-    match(TocParser::T__6);

-    setState(123);

-    var();

-   

-  }

-  catch (RecognitionException &e) {

-    _errHandler->reportError(this, e);

-    _localctx->exception = std::current_exception();

-    _errHandler->recover(this, _localctx->exception);

-  }

-

-  return _localctx;

-}

-

 //----------------- BodyContext ------------------------------------------------------------------

 

 TocParser::BodyContext::BodyContext(ParserRuleContext *parent, size_t invokingState)

@@ -728,7 +618,7 @@ void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::BodyContext* TocParser::body() {

   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());

-  enterRule(_localctx, 20, TocParser::RuleBody);

+  enterRule(_localctx, 16, TocParser::RuleBody);

   size_t _la = 0;

 

 #if __cplusplus > 201703L

@@ -740,9 +630,9 @@ TocParser::BodyContext* TocParser::body() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(125);

+    setState(119);

     match(TocParser::T__7);

-    setState(129);

+    setState(123);

     _errHandler->sync(this);

     _la = _input->LA(1);

     while ((((_la & ~ 0x3fULL) == 0) &&

@@ -753,13 +643,13 @@ TocParser::BodyContext* TocParser::body() {
       | (1ULL << TocParser::T__12)

       | (1ULL << TocParser::INTLIT)

       | (1ULL << TocParser::NAME))) != 0)) {

-      setState(126);

+      setState(120);

       stmt();

-      setState(131);

+      setState(125);

       _errHandler->sync(this);

       _la = _input->LA(1);

     }

-    setState(132);

+    setState(126);

     match(TocParser::T__8);

    

   }

@@ -809,7 +699,7 @@ void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::StructDeclContext* TocParser::structDecl() {

   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());

-  enterRule(_localctx, 22, TocParser::RuleStructDecl);

+  enterRule(_localctx, 18, TocParser::RuleStructDecl);

   size_t _la = 0;

 

 #if __cplusplus > 201703L

@@ -821,23 +711,23 @@ TocParser::StructDeclContext* TocParser::structDecl() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(134);

+    setState(128);

     match(TocParser::T__9);

-    setState(135);

+    setState(129);

     structName();

-    setState(136);

+    setState(130);

     match(TocParser::T__7);

-    setState(140);

+    setState(134);

     _errHandler->sync(this);

     _la = _input->LA(1);

     while (_la == TocParser::NAME) {

-      setState(137);

+      setState(131);

       structMember();

-      setState(142);

+      setState(136);

       _errHandler->sync(this);

       _la = _input->LA(1);

     }

-    setState(143);

+    setState(137);

     match(TocParser::T__8);

    

   }

@@ -883,7 +773,7 @@ void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener)
 

 TocParser::StructMemberContext* TocParser::structMember() {

   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());

-  enterRule(_localctx, 24, TocParser::RuleStructMember);

+  enterRule(_localctx, 20, TocParser::RuleStructMember);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -893,19 +783,19 @@ TocParser::StructMemberContext* TocParser::structMember() {
     exitRule();

   });

   try {

-    setState(147);

+    setState(141);

     _errHandler->sync(this);

     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 7, _ctx)) {

     case 1: {

       enterOuterAlt(_localctx, 1);

-      setState(145);

+      setState(139);

       structVar();

       break;

     }

 

     case 2: {

       enterOuterAlt(_localctx, 2);

-      setState(146);

+      setState(140);

       structMethod();

       break;

     }

@@ -953,7 +843,7 @@ void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::StructVarContext* TocParser::structVar() {

   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());

-  enterRule(_localctx, 26, TocParser::RuleStructVar);

+  enterRule(_localctx, 22, TocParser::RuleStructVar);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -964,7 +854,7 @@ TocParser::StructVarContext* TocParser::structVar() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(149);

+    setState(143);

     var();

    

   }

@@ -1006,7 +896,7 @@ void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener)
 

 TocParser::StructMethodContext* TocParser::structMethod() {

   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());

-  enterRule(_localctx, 28, TocParser::RuleStructMethod);

+  enterRule(_localctx, 24, TocParser::RuleStructMethod);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1017,7 +907,7 @@ TocParser::StructMethodContext* TocParser::structMethod() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(151);

+    setState(145);

     func();

    

   }

@@ -1079,7 +969,7 @@ void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::StmtContext* TocParser::stmt() {

   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());

-  enterRule(_localctx, 30, TocParser::RuleStmt);

+  enterRule(_localctx, 26, TocParser::RuleStmt);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1090,41 +980,41 @@ TocParser::StmtContext* TocParser::stmt() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(159);

+    setState(153);

     _errHandler->sync(this);

     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 8, _ctx)) {

     case 1: {

-      setState(153);

+      setState(147);

       varDecl();

       break;

     }

 

     case 2: {

-      setState(154);

+      setState(148);

       conditional();

       break;

     }

 

     case 3: {

-      setState(155);

+      setState(149);

       loop();

       break;

     }

 

     case 4: {

-      setState(156);

+      setState(150);

       assignment();

       break;

     }

 

     case 5: {

-      setState(157);

+      setState(151);

       returnStmt();

       break;

     }

 

     case 6: {

-      setState(158);

+      setState(152);

       expr();

       break;

     }

@@ -1172,7 +1062,7 @@ void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener)
 

 TocParser::ConditionalContext* TocParser::conditional() {

   ConditionalContext *_localctx = _tracker.createInstance<ConditionalContext>(_ctx, getState());

-  enterRule(_localctx, 32, TocParser::RuleConditional);

+  enterRule(_localctx, 28, TocParser::RuleConditional);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1183,7 +1073,7 @@ TocParser::ConditionalContext* TocParser::conditional() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(161);

+    setState(155);

     ifCond();

    

   }

@@ -1229,7 +1119,7 @@ void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::IfCondContext* TocParser::ifCond() {

   IfCondContext *_localctx = _tracker.createInstance<IfCondContext>(_ctx, getState());

-  enterRule(_localctx, 34, TocParser::RuleIfCond);

+  enterRule(_localctx, 30, TocParser::RuleIfCond);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1240,11 +1130,11 @@ TocParser::IfCondContext* TocParser::ifCond() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(163);

+    setState(157);

     match(TocParser::T__10);

-    setState(164);

+    setState(158);

     expr();

-    setState(165);

+    setState(159);

     body();

    

   }

@@ -1286,7 +1176,7 @@ void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::LoopContext* TocParser::loop() {

   LoopContext *_localctx = _tracker.createInstance<LoopContext>(_ctx, getState());

-  enterRule(_localctx, 36, TocParser::RuleLoop);

+  enterRule(_localctx, 32, TocParser::RuleLoop);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1297,7 +1187,7 @@ TocParser::LoopContext* TocParser::loop() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(167);

+    setState(161);

     whileLoop();

    

   }

@@ -1343,7 +1233,7 @@ void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::WhileLoopContext* TocParser::whileLoop() {

   WhileLoopContext *_localctx = _tracker.createInstance<WhileLoopContext>(_ctx, getState());

-  enterRule(_localctx, 38, TocParser::RuleWhileLoop);

+  enterRule(_localctx, 34, TocParser::RuleWhileLoop);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1354,11 +1244,11 @@ TocParser::WhileLoopContext* TocParser::whileLoop() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(169);

+    setState(163);

     match(TocParser::T__11);

-    setState(170);

+    setState(164);

     expr();

-    setState(171);

+    setState(165);

     body();

    

   }

@@ -1404,7 +1294,7 @@ void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::AssignmentContext* TocParser::assignment() {

   AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());

-  enterRule(_localctx, 40, TocParser::RuleAssignment);

+  enterRule(_localctx, 36, TocParser::RuleAssignment);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1415,11 +1305,11 @@ TocParser::AssignmentContext* TocParser::assignment() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(173);

+    setState(167);

     identifier();

-    setState(174);

+    setState(168);

     match(TocParser::T__2);

-    setState(175);

+    setState(169);

     expr();

    

   }

@@ -1461,7 +1351,7 @@ void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::ReturnStmtContext* TocParser::returnStmt() {

   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());

-  enterRule(_localctx, 42, TocParser::RuleReturnStmt);

+  enterRule(_localctx, 38, TocParser::RuleReturnStmt);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1472,9 +1362,9 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(177);

+    setState(171);

     match(TocParser::T__12);

-    setState(178);

+    setState(172);

     expr();

    

   }

@@ -1540,7 +1430,7 @@ void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::ExprContext* TocParser::expr() {

   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());

-  enterRule(_localctx, 44, TocParser::RuleExpr);

+  enterRule(_localctx, 40, TocParser::RuleExpr);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1550,54 +1440,54 @@ TocParser::ExprContext* TocParser::expr() {
     exitRule();

   });

   try {

-    setState(187);

+    setState(181);

     _errHandler->sync(this);

     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 9, _ctx)) {

     case 1: {

       enterOuterAlt(_localctx, 1);

-      setState(180);

+      setState(174);

       funcCall();

       break;

     }

 

     case 2: {

       enterOuterAlt(_localctx, 2);

-      setState(181);

+      setState(175);

       literal();

       break;

     }

 

     case 3: {

       enterOuterAlt(_localctx, 3);

-      setState(182);

+      setState(176);

       identifier();

       break;

     }

 

     case 4: {

       enterOuterAlt(_localctx, 4);

-      setState(183);

+      setState(177);

       subscript();

       break;

     }

 

     case 5: {

       enterOuterAlt(_localctx, 5);

-      setState(184);

+      setState(178);

       memberAccess();

       break;

     }

 

     case 6: {

       enterOuterAlt(_localctx, 6);

-      setState(185);

+      setState(179);

       parenExpr();

       break;

     }

 

     case 7: {

       enterOuterAlt(_localctx, 7);

-      setState(186);

+      setState(180);

       operatorExpr();

       break;

     }

@@ -1665,7 +1555,7 @@ void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::NonOpExprContext* TocParser::nonOpExpr() {

   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());

-  enterRule(_localctx, 46, TocParser::RuleNonOpExpr);

+  enterRule(_localctx, 42, TocParser::RuleNonOpExpr);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1675,47 +1565,47 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() {
     exitRule();

   });

   try {

-    setState(195);

+    setState(189);

     _errHandler->sync(this);

     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 10, _ctx)) {

     case 1: {

       enterOuterAlt(_localctx, 1);

-      setState(189);

+      setState(183);

       funcCall();

       break;

     }

 

     case 2: {

       enterOuterAlt(_localctx, 2);

-      setState(190);

+      setState(184);

       literal();

       break;

     }

 

     case 3: {

       enterOuterAlt(_localctx, 3);

-      setState(191);

+      setState(185);

       identifier();

       break;

     }

 

     case 4: {

       enterOuterAlt(_localctx, 4);

-      setState(192);

+      setState(186);

       subscript();

       break;

     }

 

     case 5: {

       enterOuterAlt(_localctx, 5);

-      setState(193);

+      setState(187);

       memberAccess();

       break;

     }

 

     case 6: {

       enterOuterAlt(_localctx, 6);

-      setState(194);

+      setState(188);

       parenExpr();

       break;

     }

@@ -1744,6 +1634,10 @@ TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() {
   return getRuleContext<TocParser::FuncCallContext>(0);

 }

 

+TocParser::LiteralContext* TocParser::NonSubscriptExprContext::literal() {

+  return getRuleContext<TocParser::LiteralContext>(0);

+}

+

 TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() {

   return getRuleContext<TocParser::IdentifierContext>(0);

 }

@@ -1775,7 +1669,7 @@ void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *liste
 

 TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {

   NonSubscriptExprContext *_localctx = _tracker.createInstance<NonSubscriptExprContext>(_ctx, getState());

-  enterRule(_localctx, 48, TocParser::RuleNonSubscriptExpr);

+  enterRule(_localctx, 44, TocParser::RuleNonSubscriptExpr);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1785,37 +1679,162 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {
     exitRule();

   });

   try {

-    setState(201);

+    setState(196);

     _errHandler->sync(this);

     switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 11, _ctx)) {

     case 1: {

       enterOuterAlt(_localctx, 1);

-      setState(197);

+      setState(191);

       funcCall();

       break;

     }

 

     case 2: {

       enterOuterAlt(_localctx, 2);

-      setState(198);

-      identifier();

+      setState(192);

+      literal();

       break;

     }

 

     case 3: {

       enterOuterAlt(_localctx, 3);

-      setState(199);

-      memberAccess();

+      setState(193);

+      identifier();

       break;

     }

 

     case 4: {

       enterOuterAlt(_localctx, 4);

+      setState(194);

+      memberAccess();

+      break;

+    }

+

+    case 5: {

+      enterOuterAlt(_localctx, 5);

+      setState(195);

+      parenExpr();

+      break;

+    }

+

+    default:

+      break;

+    }

+   

+  }

+  catch (RecognitionException &e) {

+    _errHandler->reportError(this, e);

+    _localctx->exception = std::current_exception();

+    _errHandler->recover(this, _localctx->exception);

+  }

+

+  return _localctx;

+}

+

+//----------------- NonAccessExprContext ------------------------------------------------------------------

+

+TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState)

+  : ParserRuleContext(parent, invokingState) {

+}

+

+TocParser::FuncCallContext* TocParser::NonAccessExprContext::funcCall() {

+  return getRuleContext<TocParser::FuncCallContext>(0);

+}

+

+TocParser::LiteralContext* TocParser::NonAccessExprContext::literal() {

+  return getRuleContext<TocParser::LiteralContext>(0);

+}

+

+TocParser::IdentifierContext* TocParser::NonAccessExprContext::identifier() {

+  return getRuleContext<TocParser::IdentifierContext>(0);

+}

+

+TocParser::SubscriptContext* TocParser::NonAccessExprContext::subscript() {

+  return getRuleContext<TocParser::SubscriptContext>(0);

+}

+

+TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() {

+  return getRuleContext<TocParser::ParenExprContext>(0);

+}

+

+TocParser::OperatorExprContext* TocParser::NonAccessExprContext::operatorExpr() {

+  return getRuleContext<TocParser::OperatorExprContext>(0);

+}

+

+

+size_t TocParser::NonAccessExprContext::getRuleIndex() const {

+  return TocParser::RuleNonAccessExpr;

+}

+

+void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) {

+  auto parserListener = dynamic_cast<TocListener *>(listener);

+  if (parserListener != nullptr)

+    parserListener->enterNonAccessExpr(this);

+}

+

+void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) {

+  auto parserListener = dynamic_cast<TocListener *>(listener);

+  if (parserListener != nullptr)

+    parserListener->exitNonAccessExpr(this);

+}

+

+TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {

+  NonAccessExprContext *_localctx = _tracker.createInstance<NonAccessExprContext>(_ctx, getState());

+  enterRule(_localctx, 46, TocParser::RuleNonAccessExpr);

+

+#if __cplusplus > 201703L

+  auto onExit = finally([=, this] {

+#else

+  auto onExit = finally([=] {

+#endif

+    exitRule();

+  });

+  try {

+    setState(204);

+    _errHandler->sync(this);

+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx)) {

+    case 1: {

+      enterOuterAlt(_localctx, 1);

+      setState(198);

+      funcCall();

+      break;

+    }

+

+    case 2: {

+      enterOuterAlt(_localctx, 2);

+      setState(199);

+      literal();

+      break;

+    }

+

+    case 3: {

+      enterOuterAlt(_localctx, 3);

       setState(200);

+      identifier();

+      break;

+    }

+

+    case 4: {

+      enterOuterAlt(_localctx, 4);

+      setState(201);

+      subscript();

+      break;

+    }

+

+    case 5: {

+      enterOuterAlt(_localctx, 5);

+      setState(202);

       parenExpr();

       break;

     }

 

+    case 6: {

+      enterOuterAlt(_localctx, 6);

+      setState(203);

+      operatorExpr();

+      break;

+    }

+

     default:

       break;

     }

@@ -1867,7 +1886,7 @@ void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::FuncCallContext* TocParser::funcCall() {

   FuncCallContext *_localctx = _tracker.createInstance<FuncCallContext>(_ctx, getState());

-  enterRule(_localctx, 50, TocParser::RuleFuncCall);

+  enterRule(_localctx, 48, TocParser::RuleFuncCall);

   size_t _la = 0;

 

 #if __cplusplus > 201703L

@@ -1879,11 +1898,11 @@ TocParser::FuncCallContext* TocParser::funcCall() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(203);

+    setState(206);

     funcName();

-    setState(204);

+    setState(207);

     match(TocParser::T__4);

-    setState(213);

+    setState(216);

     _errHandler->sync(this);

 

     _la = _input->LA(1);

@@ -1891,22 +1910,22 @@ TocParser::FuncCallContext* TocParser::funcCall() {
       ((1ULL << _la) & ((1ULL << TocParser::T__4)

       | (1ULL << TocParser::INTLIT)

       | (1ULL << TocParser::NAME))) != 0)) {

-      setState(205);

+      setState(208);

       expr();

-      setState(210);

+      setState(213);

       _errHandler->sync(this);

       _la = _input->LA(1);

       while (_la == TocParser::T__6) {

-        setState(206);

+        setState(209);

         match(TocParser::T__6);

-        setState(207);

+        setState(210);

         expr();

-        setState(212);

+        setState(215);

         _errHandler->sync(this);

         _la = _input->LA(1);

       }

     }

-    setState(215);

+    setState(218);

     match(TocParser::T__5);

    

   }

@@ -1948,7 +1967,7 @@ void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener)
 

 TocParser::OperatorExprContext* TocParser::operatorExpr() {

   OperatorExprContext *_localctx = _tracker.createInstance<OperatorExprContext>(_ctx, getState());

-  enterRule(_localctx, 52, TocParser::RuleOperatorExpr);

+  enterRule(_localctx, 50, TocParser::RuleOperatorExpr);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -1959,7 +1978,7 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(217);

+    setState(220);

     binaryOperator();

    

   }

@@ -2013,7 +2032,7 @@ void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listene
 

 TocParser::BinaryOperatorContext* TocParser::binaryOperator() {

   BinaryOperatorContext *_localctx = _tracker.createInstance<BinaryOperatorContext>(_ctx, getState());

-  enterRule(_localctx, 54, TocParser::RuleBinaryOperator);

+  enterRule(_localctx, 52, TocParser::RuleBinaryOperator);

   size_t _la = 0;

 

 #if __cplusplus > 201703L

@@ -2025,21 +2044,21 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(219);

+    setState(222);

     nonOpExpr();

-    setState(220);

+    setState(223);

     match(TocParser::BINARY_OPERATOR);

-    setState(221);

+    setState(224);

     nonOpExpr();

-    setState(226);

+    setState(229);

     _errHandler->sync(this);

     _la = _input->LA(1);

     while (_la == TocParser::BINARY_OPERATOR) {

-      setState(222);

+      setState(225);

       match(TocParser::BINARY_OPERATOR);

-      setState(223);

+      setState(226);

       nonOpExpr();

-      setState(228);

+      setState(231);

       _errHandler->sync(this);

       _la = _input->LA(1);

     }

@@ -2083,7 +2102,7 @@ void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::IdentifierContext* TocParser::identifier() {

   IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());

-  enterRule(_localctx, 56, TocParser::RuleIdentifier);

+  enterRule(_localctx, 54, TocParser::RuleIdentifier);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2094,7 +2113,7 @@ TocParser::IdentifierContext* TocParser::identifier() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(229);

+    setState(232);

     varName();

    

   }

@@ -2136,7 +2155,7 @@ void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::LiteralContext* TocParser::literal() {

   LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());

-  enterRule(_localctx, 58, TocParser::RuleLiteral);

+  enterRule(_localctx, 56, TocParser::RuleLiteral);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2147,7 +2166,7 @@ TocParser::LiteralContext* TocParser::literal() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(231);

+    setState(234);

     match(TocParser::INTLIT);

    

   }

@@ -2193,7 +2212,7 @@ void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::SubscriptContext* TocParser::subscript() {

   SubscriptContext *_localctx = _tracker.createInstance<SubscriptContext>(_ctx, getState());

-  enterRule(_localctx, 60, TocParser::RuleSubscript);

+  enterRule(_localctx, 58, TocParser::RuleSubscript);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2204,13 +2223,13 @@ TocParser::SubscriptContext* TocParser::subscript() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(233);

+    setState(236);

     nonSubscriptExpr();

-    setState(234);

+    setState(237);

     match(TocParser::T__13);

-    setState(235);

+    setState(238);

     expr();

-    setState(236);

+    setState(239);

     match(TocParser::T__14);

    

   }

@@ -2256,7 +2275,7 @@ void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener)
 

 TocParser::MemberAccessContext* TocParser::memberAccess() {

   MemberAccessContext *_localctx = _tracker.createInstance<MemberAccessContext>(_ctx, getState());

-  enterRule(_localctx, 62, TocParser::RuleMemberAccess);

+  enterRule(_localctx, 60, TocParser::RuleMemberAccess);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2267,11 +2286,11 @@ TocParser::MemberAccessContext* TocParser::memberAccess() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(238);

+    setState(241);

     identifier();

-    setState(239);

+    setState(242);

     match(TocParser::T__15);

-    setState(240);

+    setState(243);

     identifier();

    

   }

@@ -2313,7 +2332,7 @@ void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::ParenExprContext* TocParser::parenExpr() {

   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());

-  enterRule(_localctx, 64, TocParser::RuleParenExpr);

+  enterRule(_localctx, 62, TocParser::RuleParenExpr);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2324,11 +2343,11 @@ TocParser::ParenExprContext* TocParser::parenExpr() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(242);

+    setState(245);

     match(TocParser::T__4);

-    setState(243);

+    setState(246);

     expr();

-    setState(244);

+    setState(247);

     match(TocParser::T__5);

    

   }

@@ -2370,7 +2389,7 @@ void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::FuncNameContext* TocParser::funcName() {

   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());

-  enterRule(_localctx, 66, TocParser::RuleFuncName);

+  enterRule(_localctx, 64, TocParser::RuleFuncName);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2381,7 +2400,7 @@ TocParser::FuncNameContext* TocParser::funcName() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(246);

+    setState(249);

     match(TocParser::NAME);

    

   }

@@ -2423,7 +2442,7 @@ void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::VarNameContext* TocParser::varName() {

   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());

-  enterRule(_localctx, 68, TocParser::RuleVarName);

+  enterRule(_localctx, 66, TocParser::RuleVarName);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2434,7 +2453,7 @@ TocParser::VarNameContext* TocParser::varName() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(248);

+    setState(251);

     match(TocParser::NAME);

    

   }

@@ -2476,7 +2495,7 @@ void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::TypeNameContext* TocParser::typeName() {

   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());

-  enterRule(_localctx, 70, TocParser::RuleTypeName);

+  enterRule(_localctx, 68, TocParser::RuleTypeName);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2487,7 +2506,7 @@ TocParser::TypeNameContext* TocParser::typeName() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(250);

+    setState(253);

     match(TocParser::NAME);

    

   }

@@ -2529,7 +2548,7 @@ void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) {
 

 TocParser::StructNameContext* TocParser::structName() {

   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());

-  enterRule(_localctx, 72, TocParser::RuleStructName);

+  enterRule(_localctx, 70, TocParser::RuleStructName);

 

 #if __cplusplus > 201703L

   auto onExit = finally([=, this] {

@@ -2540,7 +2559,7 @@ TocParser::StructNameContext* TocParser::structName() {
   });

   try {

     enterOuterAlt(_localctx, 1);

-    setState(252);

+    setState(255);

     match(TocParser::NAME);

    

   }

@@ -2563,12 +2582,11 @@ std::vector<uint16_t> TocParser::_serializedATN;
 

 std::vector<std::string> TocParser::_ruleNames = {

   "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", 

-  "firstParameter", "additionalParameter", "body", "structDecl", "structMember", 

-  "structVar", "structMethod", "stmt", "conditional", "ifCond", "loop", 

-  "whileLoop", "assignment", "returnStmt", "expr", "nonOpExpr", "nonSubscriptExpr", 

-  "funcCall", "operatorExpr", "binaryOperator", "identifier", "literal", 

-  "subscript", "memberAccess", "parenExpr", "funcName", "varName", "typeName", 

-  "structName"

+  "body", "structDecl", "structMember", "structVar", "structMethod", "stmt", 

+  "conditional", "ifCond", "loop", "whileLoop", "assignment", "returnStmt", 

+  "expr", "nonOpExpr", "nonSubscriptExpr", "nonAccessExpr", "funcCall", 

+  "operatorExpr", "binaryOperator", "identifier", "literal", "subscript", 

+  "memberAccess", "parenExpr", "funcName", "varName", "typeName", "structName"

 };

 

 std::vector<std::string> TocParser::_literalNames = {

@@ -2601,7 +2619,7 @@ TocParser::Initializer::Initializer() {
 

   static const uint16_t serializedATNSegment0[] = {

     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, 

-       0x3, 0x17, 0x101, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 

+       0x3, 0x17, 0x104, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, 

        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, 

        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, 

        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, 

@@ -2612,162 +2630,167 @@ TocParser::Initializer::Initializer() {
        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, 

        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, 

        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, 

-       0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, 

-       0x9, 0x26, 0x3, 0x2, 0x6, 0x2, 0x4e, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 

-       0x4f, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 

-       0x57, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 

-       0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x62, 0xa, 0x5, 

-       0x3, 0x6, 0x3, 0x6, 0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 

-       0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 

-       0x3, 0x8, 0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x74, 0xa, 0x9, 0xc, 0x9, 

-       0xe, 0x9, 0x77, 0xb, 0x9, 0x5, 0x9, 0x79, 0xa, 0x9, 0x3, 0xa, 0x3, 

-       0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 

-       0x82, 0xa, 0xc, 0xc, 0xc, 0xe, 0xc, 0x85, 0xb, 0xc, 0x3, 0xc, 0x3, 

-       0xc, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0x8d, 0xa, 

-       0xd, 0xc, 0xd, 0xe, 0xd, 0x90, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 

-       0xe, 0x3, 0xe, 0x5, 0xe, 0x96, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 

-       0x10, 0x3, 0x10, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 

-       0x11, 0x3, 0x11, 0x5, 0x11, 0xa2, 0xa, 0x11, 0x3, 0x12, 0x3, 0x12, 

-       0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 

-       0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 

-       0x3, 0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x18, 

-       0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 

-       0x5, 0x18, 0xbe, 0xa, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 

-       0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xc6, 0xa, 0x19, 0x3, 0x1a, 

-       0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0xcc, 0xa, 0x1a, 0x3, 

-       0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x7, 0x1b, 0xd3, 

-       0xa, 0x1b, 0xc, 0x1b, 0xe, 0x1b, 0xd6, 0xb, 0x1b, 0x5, 0x1b, 0xd8, 

-       0xa, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 

-       0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1d, 0x7, 0x1d, 0xe3, 0xa, 

-       0x1d, 0xc, 0x1d, 0xe, 0x1d, 0xe6, 0xb, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 

-       0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 

-       0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 

-       0x3, 0x22, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 

-       0x3, 0x24, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, 0x3, 0x26, 0x3, 0x26, 

-       0x2, 0x2, 0x27, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 

-       0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, 0x24, 0x26, 0x28, 0x2a, 

-       0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, 0x3a, 0x3c, 0x3e, 0x40, 

-       0x42, 0x44, 0x46, 0x48, 0x4a, 0x2, 0x2, 0x2, 0xfa, 0x2, 0x4d, 0x3, 

-       0x2, 0x2, 0x2, 0x4, 0x56, 0x3, 0x2, 0x2, 0x2, 0x6, 0x58, 0x3, 0x2, 

-       0x2, 0x2, 0x8, 0x5b, 0x3, 0x2, 0x2, 0x2, 0xa, 0x63, 0x3, 0x2, 0x2, 

-       0x2, 0xc, 0x65, 0x3, 0x2, 0x2, 0x2, 0xe, 0x68, 0x3, 0x2, 0x2, 0x2, 

-       0x10, 0x78, 0x3, 0x2, 0x2, 0x2, 0x12, 0x7a, 0x3, 0x2, 0x2, 0x2, 0x14, 

-       0x7c, 0x3, 0x2, 0x2, 0x2, 0x16, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x18, 0x88, 

-       0x3, 0x2, 0x2, 0x2, 0x1a, 0x95, 0x3, 0x2, 0x2, 0x2, 0x1c, 0x97, 0x3, 

-       0x2, 0x2, 0x2, 0x1e, 0x99, 0x3, 0x2, 0x2, 0x2, 0x20, 0xa1, 0x3, 0x2, 

-       0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, 0xa5, 0x3, 0x2, 0x2, 

-       0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xab, 0x3, 0x2, 0x2, 0x2, 

-       0x2a, 0xaf, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xb3, 0x3, 0x2, 0x2, 0x2, 0x2e, 

-       0xbd, 0x3, 0x2, 0x2, 0x2, 0x30, 0xc5, 0x3, 0x2, 0x2, 0x2, 0x32, 0xcb, 

-       0x3, 0x2, 0x2, 0x2, 0x34, 0xcd, 0x3, 0x2, 0x2, 0x2, 0x36, 0xdb, 0x3, 

-       0x2, 0x2, 0x2, 0x38, 0xdd, 0x3, 0x2, 0x2, 0x2, 0x3a, 0xe7, 0x3, 0x2, 

-       0x2, 0x2, 0x3c, 0xe9, 0x3, 0x2, 0x2, 0x2, 0x3e, 0xeb, 0x3, 0x2, 0x2, 

-       0x2, 0x40, 0xf0, 0x3, 0x2, 0x2, 0x2, 0x42, 0xf4, 0x3, 0x2, 0x2, 0x2, 

-       0x44, 0xf8, 0x3, 0x2, 0x2, 0x2, 0x46, 0xfa, 0x3, 0x2, 0x2, 0x2, 0x48, 

-       0xfc, 0x3, 0x2, 0x2, 0x2, 0x4a, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4e, 

-       0x5, 0x4, 0x3, 0x2, 0x4d, 0x4c, 0x3, 0x2, 0x2, 0x2, 0x4e, 0x4f, 0x3, 

-       0x2, 0x2, 0x2, 0x4f, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x3, 0x2, 

-       0x2, 0x2, 0x50, 0x51, 0x3, 0x2, 0x2, 0x2, 0x51, 0x52, 0x7, 0x2, 0x2, 

-       0x3, 0x52, 0x3, 0x3, 0x2, 0x2, 0x2, 0x53, 0x57, 0x5, 0x6, 0x4, 0x2, 

-       0x54, 0x57, 0x5, 0xc, 0x7, 0x2, 0x55, 0x57, 0x5, 0x18, 0xd, 0x2, 

-       0x56, 0x53, 0x3, 0x2, 0x2, 0x2, 0x56, 0x54, 0x3, 0x2, 0x2, 0x2, 0x56, 

-       0x55, 0x3, 0x2, 0x2, 0x2, 0x57, 0x5, 0x3, 0x2, 0x2, 0x2, 0x58, 0x59, 

-       0x7, 0x3, 0x2, 0x2, 0x59, 0x5a, 0x5, 0x8, 0x5, 0x2, 0x5a, 0x7, 0x3, 

-       0x2, 0x2, 0x2, 0x5b, 0x5c, 0x5, 0x46, 0x24, 0x2, 0x5c, 0x5d, 0x7, 

-       0x4, 0x2, 0x2, 0x5d, 0x5e, 0x5, 0xa, 0x6, 0x2, 0x5e, 0x61, 0x3, 0x2, 

-       0x2, 0x2, 0x5f, 0x60, 0x7, 0x5, 0x2, 0x2, 0x60, 0x62, 0x5, 0x2e, 

-       0x18, 0x2, 0x61, 0x5f, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x3, 0x2, 

-       0x2, 0x2, 0x62, 0x9, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x5, 0x48, 0x25, 

-       0x2, 0x64, 0xb, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x6, 0x2, 0x2, 

-       0x66, 0x67, 0x5, 0xe, 0x8, 0x2, 0x67, 0xd, 0x3, 0x2, 0x2, 0x2, 0x68, 

-       0x69, 0x5, 0x44, 0x23, 0x2, 0x69, 0x6a, 0x7, 0x7, 0x2, 0x2, 0x6a, 

-       0x6b, 0x5, 0x10, 0x9, 0x2, 0x6b, 0x6c, 0x7, 0x8, 0x2, 0x2, 0x6c, 

-       0x6d, 0x7, 0x4, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0xa, 0x6, 0x2, 0x6e, 0x6f, 

-       0x3, 0x2, 0x2, 0x2, 0x6f, 0x70, 0x5, 0x16, 0xc, 0x2, 0x70, 0xf, 0x3, 

-       0x2, 0x2, 0x2, 0x71, 0x75, 0x5, 0x12, 0xa, 0x2, 0x72, 0x74, 0x5, 

-       0x14, 0xb, 0x2, 0x73, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x77, 0x3, 

-       0x2, 0x2, 0x2, 0x75, 0x73, 0x3, 0x2, 0x2, 0x2, 0x75, 0x76, 0x3, 0x2, 

-       0x2, 0x2, 0x76, 0x79, 0x3, 0x2, 0x2, 0x2, 0x77, 0x75, 0x3, 0x2, 0x2, 

-       0x2, 0x78, 0x71, 0x3, 0x2, 0x2, 0x2, 0x78, 0x79, 0x3, 0x2, 0x2, 0x2, 

-       0x79, 0x11, 0x3, 0x2, 0x2, 0x2, 0x7a, 0x7b, 0x5, 0x8, 0x5, 0x2, 0x7b, 

-       0x13, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7d, 0x7, 0x9, 0x2, 0x2, 0x7d, 0x7e, 

-       0x5, 0x8, 0x5, 0x2, 0x7e, 0x15, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x83, 0x7, 

-       0xa, 0x2, 0x2, 0x80, 0x82, 0x5, 0x20, 0x11, 0x2, 0x81, 0x80, 0x3, 

-       0x2, 0x2, 0x2, 0x82, 0x85, 0x3, 0x2, 0x2, 0x2, 0x83, 0x81, 0x3, 0x2, 

-       0x2, 0x2, 0x83, 0x84, 0x3, 0x2, 0x2, 0x2, 0x84, 0x86, 0x3, 0x2, 0x2, 

-       0x2, 0x85, 0x83, 0x3, 0x2, 0x2, 0x2, 0x86, 0x87, 0x7, 0xb, 0x2, 0x2, 

-       0x87, 0x17, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x7, 0xc, 0x2, 0x2, 0x89, 

-       0x8a, 0x5, 0x4a, 0x26, 0x2, 0x8a, 0x8e, 0x7, 0xa, 0x2, 0x2, 0x8b, 

-       0x8d, 0x5, 0x1a, 0xe, 0x2, 0x8c, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8d, 

-       0x90, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8c, 0x3, 0x2, 0x2, 0x2, 0x8e, 0x8f, 

-       0x3, 0x2, 0x2, 0x2, 0x8f, 0x91, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, 0x3, 

-       0x2, 0x2, 0x2, 0x91, 0x92, 0x7, 0xb, 0x2, 0x2, 0x92, 0x19, 0x3, 0x2, 

-       0x2, 0x2, 0x93, 0x96, 0x5, 0x1c, 0xf, 0x2, 0x94, 0x96, 0x5, 0x1e, 

-       0x10, 0x2, 0x95, 0x93, 0x3, 0x2, 0x2, 0x2, 0x95, 0x94, 0x3, 0x2, 

-       0x2, 0x2, 0x96, 0x1b, 0x3, 0x2, 0x2, 0x2, 0x97, 0x98, 0x5, 0x8, 0x5, 

-       0x2, 0x98, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x5, 0xe, 0x8, 0x2, 

-       0x9a, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9b, 0xa2, 0x5, 0x6, 0x4, 0x2, 0x9c, 

-       0xa2, 0x5, 0x22, 0x12, 0x2, 0x9d, 0xa2, 0x5, 0x26, 0x14, 0x2, 0x9e, 

-       0xa2, 0x5, 0x2a, 0x16, 0x2, 0x9f, 0xa2, 0x5, 0x2c, 0x17, 0x2, 0xa0, 

-       0xa2, 0x5, 0x2e, 0x18, 0x2, 0xa1, 0x9b, 0x3, 0x2, 0x2, 0x2, 0xa1, 

-       0x9c, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9d, 0x3, 0x2, 0x2, 0x2, 0xa1, 0x9e, 

-       0x3, 0x2, 0x2, 0x2, 0xa1, 0x9f, 0x3, 0x2, 0x2, 0x2, 0xa1, 0xa0, 0x3, 

-       0x2, 0x2, 0x2, 0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 

-       0x13, 0x2, 0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xd, 

-       0x2, 0x2, 0xa6, 0xa7, 0x5, 0x2e, 0x18, 0x2, 0xa7, 0xa8, 0x5, 0x16, 

-       0xc, 0x2, 0xa8, 0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x28, 

-       0x15, 0x2, 0xaa, 0x27, 0x3, 0x2, 0x2, 0x2, 0xab, 0xac, 0x7, 0xe, 

-       0x2, 0x2, 0xac, 0xad, 0x5, 0x2e, 0x18, 0x2, 0xad, 0xae, 0x5, 0x16, 

-       0xc, 0x2, 0xae, 0x29, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, 0x5, 0x3a, 

-       0x1e, 0x2, 0xb0, 0xb1, 0x7, 0x5, 0x2, 0x2, 0xb1, 0xb2, 0x5, 0x2e, 

-       0x18, 0x2, 0xb2, 0x2b, 0x3, 0x2, 0x2, 0x2, 0xb3, 0xb4, 0x7, 0xf, 

-       0x2, 0x2, 0xb4, 0xb5, 0x5, 0x2e, 0x18, 0x2, 0xb5, 0x2d, 0x3, 0x2, 

-       0x2, 0x2, 0xb6, 0xbe, 0x5, 0x34, 0x1b, 0x2, 0xb7, 0xbe, 0x5, 0x3c, 

-       0x1f, 0x2, 0xb8, 0xbe, 0x5, 0x3a, 0x1e, 0x2, 0xb9, 0xbe, 0x5, 0x3e, 

-       0x20, 0x2, 0xba, 0xbe, 0x5, 0x40, 0x21, 0x2, 0xbb, 0xbe, 0x5, 0x42, 

-       0x22, 0x2, 0xbc, 0xbe, 0x5, 0x36, 0x1c, 0x2, 0xbd, 0xb6, 0x3, 0x2, 

-       0x2, 0x2, 0xbd, 0xb7, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xb8, 0x3, 0x2, 0x2, 

-       0x2, 0xbd, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xba, 0x3, 0x2, 0x2, 0x2, 

-       0xbd, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbd, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbe, 

-       0x2f, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xc6, 0x5, 0x34, 0x1b, 0x2, 0xc0, 

-       0xc6, 0x5, 0x3c, 0x1f, 0x2, 0xc1, 0xc6, 0x5, 0x3a, 0x1e, 0x2, 0xc2, 

-       0xc6, 0x5, 0x3e, 0x20, 0x2, 0xc3, 0xc6, 0x5, 0x40, 0x21, 0x2, 0xc4, 

-       0xc6, 0x5, 0x42, 0x22, 0x2, 0xc5, 0xbf, 0x3, 0x2, 0x2, 0x2, 0xc5, 

-       0xc0, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc1, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc2, 

-       0x3, 0x2, 0x2, 0x2, 0xc5, 0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc4, 0x3, 

-       0x2, 0x2, 0x2, 0xc6, 0x31, 0x3, 0x2, 0x2, 0x2, 0xc7, 0xcc, 0x5, 0x34, 

-       0x1b, 0x2, 0xc8, 0xcc, 0x5, 0x3a, 0x1e, 0x2, 0xc9, 0xcc, 0x5, 0x40, 

-       0x21, 0x2, 0xca, 0xcc, 0x5, 0x42, 0x22, 0x2, 0xcb, 0xc7, 0x3, 0x2, 

-       0x2, 0x2, 0xcb, 0xc8, 0x3, 0x2, 0x2, 0x2, 0xcb, 0xc9, 0x3, 0x2, 0x2, 

-       0x2, 0xcb, 0xca, 0x3, 0x2, 0x2, 0x2, 0xcc, 0x33, 0x3, 0x2, 0x2, 0x2, 

-       0xcd, 0xce, 0x5, 0x44, 0x23, 0x2, 0xce, 0xd7, 0x7, 0x7, 0x2, 0x2, 

-       0xcf, 0xd4, 0x5, 0x2e, 0x18, 0x2, 0xd0, 0xd1, 0x7, 0x9, 0x2, 0x2, 

-       0xd1, 0xd3, 0x5, 0x2e, 0x18, 0x2, 0xd2, 0xd0, 0x3, 0x2, 0x2, 0x2, 

-       0xd3, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd4, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xd4, 

-       0xd5, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd6, 0xd4, 

-       0x3, 0x2, 0x2, 0x2, 0xd7, 0xcf, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 0x3, 

-       0x2, 0x2, 0x2, 0xd8, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xda, 0x7, 0x8, 

-       0x2, 0x2, 0xda, 0x35, 0x3, 0x2, 0x2, 0x2, 0xdb, 0xdc, 0x5, 0x38, 

-       0x1d, 0x2, 0xdc, 0x37, 0x3, 0x2, 0x2, 0x2, 0xdd, 0xde, 0x5, 0x30, 

-       0x19, 0x2, 0xde, 0xdf, 0x7, 0x13, 0x2, 0x2, 0xdf, 0xe4, 0x5, 0x30, 

-       0x19, 0x2, 0xe0, 0xe1, 0x7, 0x13, 0x2, 0x2, 0xe1, 0xe3, 0x5, 0x30, 

-       0x19, 0x2, 0xe2, 0xe0, 0x3, 0x2, 0x2, 0x2, 0xe3, 0xe6, 0x3, 0x2, 

-       0x2, 0x2, 0xe4, 0xe2, 0x3, 0x2, 0x2, 0x2, 0xe4, 0xe5, 0x3, 0x2, 0x2, 

-       0x2, 0xe5, 0x39, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe4, 0x3, 0x2, 0x2, 0x2, 

-       0xe7, 0xe8, 0x5, 0x46, 0x24, 0x2, 0xe8, 0x3b, 0x3, 0x2, 0x2, 0x2, 

-       0xe9, 0xea, 0x7, 0x14, 0x2, 0x2, 0xea, 0x3d, 0x3, 0x2, 0x2, 0x2, 

-       0xeb, 0xec, 0x5, 0x32, 0x1a, 0x2, 0xec, 0xed, 0x7, 0x10, 0x2, 0x2, 

-       0xed, 0xee, 0x5, 0x2e, 0x18, 0x2, 0xee, 0xef, 0x7, 0x11, 0x2, 0x2, 

-       0xef, 0x3f, 0x3, 0x2, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x3a, 0x1e, 0x2, 

-       0xf1, 0xf2, 0x7, 0x12, 0x2, 0x2, 0xf2, 0xf3, 0x5, 0x3a, 0x1e, 0x2, 

-       0xf3, 0x41, 0x3, 0x2, 0x2, 0x2, 0xf4, 0xf5, 0x7, 0x7, 0x2, 0x2, 0xf5, 

-       0xf6, 0x5, 0x2e, 0x18, 0x2, 0xf6, 0xf7, 0x7, 0x8, 0x2, 0x2, 0xf7, 

-       0x43, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf9, 0x7, 0x15, 0x2, 0x2, 0xf9, 

-       0x45, 0x3, 0x2, 0x2, 0x2, 0xfa, 0xfb, 0x7, 0x15, 0x2, 0x2, 0xfb, 

-       0x47, 0x3, 0x2, 0x2, 0x2, 0xfc, 0xfd, 0x7, 0x15, 0x2, 0x2, 0xfd, 

-       0x49, 0x3, 0x2, 0x2, 0x2, 0xfe, 0xff, 0x7, 0x15, 0x2, 0x2, 0xff, 

-       0x4b, 0x3, 0x2, 0x2, 0x2, 0x11, 0x4f, 0x56, 0x61, 0x75, 0x78, 0x83, 

-       0x8e, 0x95, 0xa1, 0xbd, 0xc5, 0xcb, 0xd4, 0xd7, 0xe4, 

+       0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x3, 0x2, 

+       0x6, 0x2, 0x4c, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 0x4d, 0x3, 0x2, 0x3, 

+       0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x55, 0xa, 0x3, 0x3, 

+       0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 

+       0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x60, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, 

+       0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 

+       0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, 

+       0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x73, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, 

+       0x76, 0xb, 0x9, 0x5, 0x9, 0x78, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x7, 

+       0xa, 0x7c, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x7f, 0xb, 0xa, 0x3, 0xa, 

+       0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x87, 

+       0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x8a, 0xb, 0xb, 0x3, 0xb, 0x3, 0xb, 

+       0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x90, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, 

+       0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 

+       0xf, 0x3, 0xf, 0x5, 0xf, 0x9c, 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, 

+       0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, 

+       0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 

+       0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 

+       0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, 

+       0x16, 0xb8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 

+       0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0xc0, 0xa, 0x17, 0x3, 0x18, 0x3, 

+       0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0xc7, 0xa, 0x18, 

+       0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 

+       0x5, 0x19, 0xcf, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 

+       0x1a, 0x3, 0x1a, 0x7, 0x1a, 0xd6, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, 

+       0xd9, 0xb, 0x1a, 0x5, 0x1a, 0xdb, 0xa, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 

+       0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 

+       0x3, 0x1c, 0x7, 0x1c, 0xe6, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0xe9, 

+       0xb, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, 

+       0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, 

+       0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 

+       0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 

+       0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x2, 0x2, 0x26, 0x2, 0x4, 0x6, 0x8, 

+       0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 

+       0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 

+       0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x2, 0x2, 0x2, 

+       0x104, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4, 0x54, 0x3, 0x2, 0x2, 0x2, 

+       0x6, 0x56, 0x3, 0x2, 0x2, 0x2, 0x8, 0x59, 0x3, 0x2, 0x2, 0x2, 0xa, 

+       0x61, 0x3, 0x2, 0x2, 0x2, 0xc, 0x63, 0x3, 0x2, 0x2, 0x2, 0xe, 0x66, 

+       0x3, 0x2, 0x2, 0x2, 0x10, 0x77, 0x3, 0x2, 0x2, 0x2, 0x12, 0x79, 0x3, 

+       0x2, 0x2, 0x2, 0x14, 0x82, 0x3, 0x2, 0x2, 0x2, 0x16, 0x8f, 0x3, 0x2, 

+       0x2, 0x2, 0x18, 0x91, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x93, 0x3, 0x2, 0x2, 

+       0x2, 0x1c, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x9d, 0x3, 0x2, 0x2, 0x2, 

+       0x20, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, 

+       0xa5, 0x3, 0x2, 0x2, 0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xad, 

+       0x3, 0x2, 0x2, 0x2, 0x2a, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xbf, 0x3, 

+       0x2, 0x2, 0x2, 0x2e, 0xc6, 0x3, 0x2, 0x2, 0x2, 0x30, 0xce, 0x3, 0x2, 

+       0x2, 0x2, 0x32, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x34, 0xde, 0x3, 0x2, 0x2, 

+       0x2, 0x36, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x38, 0xea, 0x3, 0x2, 0x2, 0x2, 

+       0x3a, 0xec, 0x3, 0x2, 0x2, 0x2, 0x3c, 0xee, 0x3, 0x2, 0x2, 0x2, 0x3e, 

+       0xf3, 0x3, 0x2, 0x2, 0x2, 0x40, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x42, 0xfb, 

+       0x3, 0x2, 0x2, 0x2, 0x44, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x46, 0xff, 0x3, 

+       0x2, 0x2, 0x2, 0x48, 0x101, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4c, 0x5, 

+       0x4, 0x3, 0x2, 0x4b, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4d, 0x3, 0x2, 

+       0x2, 0x2, 0x4d, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x3, 0x2, 0x2, 

+       0x2, 0x4e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x7, 0x2, 0x2, 0x3, 

+       0x50, 0x3, 0x3, 0x2, 0x2, 0x2, 0x51, 0x55, 0x5, 0x6, 0x4, 0x2, 0x52, 

+       0x55, 0x5, 0xc, 0x7, 0x2, 0x53, 0x55, 0x5, 0x14, 0xb, 0x2, 0x54, 

+       0x51, 0x3, 0x2, 0x2, 0x2, 0x54, 0x52, 0x3, 0x2, 0x2, 0x2, 0x54, 0x53, 

+       0x3, 0x2, 0x2, 0x2, 0x55, 0x5, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x7, 

+       0x3, 0x2, 0x2, 0x57, 0x58, 0x5, 0x8, 0x5, 0x2, 0x58, 0x7, 0x3, 0x2, 

+       0x2, 0x2, 0x59, 0x5a, 0x5, 0x44, 0x23, 0x2, 0x5a, 0x5b, 0x7, 0x4, 

+       0x2, 0x2, 0x5b, 0x5c, 0x5, 0xa, 0x6, 0x2, 0x5c, 0x5f, 0x3, 0x2, 0x2, 

+       0x2, 0x5d, 0x5e, 0x7, 0x5, 0x2, 0x2, 0x5e, 0x60, 0x5, 0x2a, 0x16, 

+       0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x60, 0x3, 0x2, 0x2, 0x2, 

+       0x60, 0x9, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x46, 0x24, 0x2, 

+       0x62, 0xb, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x7, 0x6, 0x2, 0x2, 0x64, 

+       0x65, 0x5, 0xe, 0x8, 0x2, 0x65, 0xd, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, 

+       0x5, 0x42, 0x22, 0x2, 0x67, 0x68, 0x7, 0x7, 0x2, 0x2, 0x68, 0x69, 

+       0x5, 0x10, 0x9, 0x2, 0x69, 0x6a, 0x7, 0x8, 0x2, 0x2, 0x6a, 0x6b, 

+       0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, 0x5, 0xa, 0x6, 0x2, 0x6c, 0x6d, 0x3, 

+       0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x12, 0xa, 0x2, 0x6e, 0xf, 0x3, 0x2, 

+       0x2, 0x2, 0x6f, 0x74, 0x5, 0x8, 0x5, 0x2, 0x70, 0x71, 0x7, 0x9, 0x2, 

+       0x2, 0x71, 0x73, 0x5, 0x8, 0x5, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, 

+       0x73, 0x76, 0x3, 0x2, 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 

+       0x75, 0x3, 0x2, 0x2, 0x2, 0x75, 0x78, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, 

+       0x3, 0x2, 0x2, 0x2, 0x77, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, 0x3, 

+       0x2, 0x2, 0x2, 0x78, 0x11, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7d, 0x7, 0xa, 

+       0x2, 0x2, 0x7a, 0x7c, 0x5, 0x1c, 0xf, 0x2, 0x7b, 0x7a, 0x3, 0x2, 

+       0x2, 0x2, 0x7c, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7b, 0x3, 0x2, 0x2, 

+       0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x80, 0x3, 0x2, 0x2, 0x2, 

+       0x7f, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0xb, 0x2, 0x2, 0x81, 

+       0x13, 0x3, 0x2, 0x2, 0x2, 0x82, 0x83, 0x7, 0xc, 0x2, 0x2, 0x83, 0x84, 

+       0x5, 0x48, 0x25, 0x2, 0x84, 0x88, 0x7, 0xa, 0x2, 0x2, 0x85, 0x87, 

+       0x5, 0x16, 0xc, 0x2, 0x86, 0x85, 0x3, 0x2, 0x2, 0x2, 0x87, 0x8a, 

+       0x3, 0x2, 0x2, 0x2, 0x88, 0x86, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x3, 

+       0x2, 0x2, 0x2, 0x89, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, 

+       0x2, 0x2, 0x8b, 0x8c, 0x7, 0xb, 0x2, 0x2, 0x8c, 0x15, 0x3, 0x2, 0x2, 

+       0x2, 0x8d, 0x90, 0x5, 0x18, 0xd, 0x2, 0x8e, 0x90, 0x5, 0x1a, 0xe, 

+       0x2, 0x8f, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x8e, 0x3, 0x2, 0x2, 0x2, 

+       0x90, 0x17, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, 0x5, 0x8, 0x5, 0x2, 0x92, 

+       0x19, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, 0x5, 0xe, 0x8, 0x2, 0x94, 0x1b, 

+       0x3, 0x2, 0x2, 0x2, 0x95, 0x9c, 0x5, 0x6, 0x4, 0x2, 0x96, 0x9c, 0x5, 

+       0x1e, 0x10, 0x2, 0x97, 0x9c, 0x5, 0x22, 0x12, 0x2, 0x98, 0x9c, 0x5, 

+       0x26, 0x14, 0x2, 0x99, 0x9c, 0x5, 0x28, 0x15, 0x2, 0x9a, 0x9c, 0x5, 

+       0x2a, 0x16, 0x2, 0x9b, 0x95, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x96, 0x3, 

+       0x2, 0x2, 0x2, 0x9b, 0x97, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x98, 0x3, 0x2, 

+       0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9a, 0x3, 0x2, 0x2, 

+       0x2, 0x9c, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x20, 0x11, 

+       0x2, 0x9e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0xd, 0x2, 0x2, 

+       0xa0, 0xa1, 0x5, 0x2a, 0x16, 0x2, 0xa1, 0xa2, 0x5, 0x12, 0xa, 0x2, 

+       0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 0x13, 0x2, 

+       0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xe, 0x2, 0x2, 0xa6, 

+       0xa7, 0x5, 0x2a, 0x16, 0x2, 0xa7, 0xa8, 0x5, 0x12, 0xa, 0x2, 0xa8, 

+       0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x38, 0x1d, 0x2, 0xaa, 

+       0xab, 0x7, 0x5, 0x2, 0x2, 0xab, 0xac, 0x5, 0x2a, 0x16, 0x2, 0xac, 

+       0x27, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x7, 0xf, 0x2, 0x2, 0xae, 0xaf, 

+       0x5, 0x2a, 0x16, 0x2, 0xaf, 0x29, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb8, 

+       0x5, 0x32, 0x1a, 0x2, 0xb1, 0xb8, 0x5, 0x3a, 0x1e, 0x2, 0xb2, 0xb8, 

+       0x5, 0x38, 0x1d, 0x2, 0xb3, 0xb8, 0x5, 0x3c, 0x1f, 0x2, 0xb4, 0xb8, 

+       0x5, 0x3e, 0x20, 0x2, 0xb5, 0xb8, 0x5, 0x40, 0x21, 0x2, 0xb6, 0xb8, 

+       0x5, 0x34, 0x1b, 0x2, 0xb7, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb1, 

+       0x3, 0x2, 0x2, 0x2, 0xb7, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb3, 0x3, 

+       0x2, 0x2, 0x2, 0xb7, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb5, 0x3, 0x2, 

+       0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x2b, 0x3, 0x2, 0x2, 

+       0x2, 0xb9, 0xc0, 0x5, 0x32, 0x1a, 0x2, 0xba, 0xc0, 0x5, 0x3a, 0x1e, 

+       0x2, 0xbb, 0xc0, 0x5, 0x38, 0x1d, 0x2, 0xbc, 0xc0, 0x5, 0x3c, 0x1f, 

+       0x2, 0xbd, 0xc0, 0x5, 0x3e, 0x20, 0x2, 0xbe, 0xc0, 0x5, 0x40, 0x21, 

+       0x2, 0xbf, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xba, 0x3, 0x2, 0x2, 0x2, 

+       0xbf, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbf, 

+       0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0x2d, 

+       0x3, 0x2, 0x2, 0x2, 0xc1, 0xc7, 0x5, 0x32, 0x1a, 0x2, 0xc2, 0xc7, 

+       0x5, 0x3a, 0x1e, 0x2, 0xc3, 0xc7, 0x5, 0x38, 0x1d, 0x2, 0xc4, 0xc7, 

+       0x5, 0x3e, 0x20, 0x2, 0xc5, 0xc7, 0x5, 0x40, 0x21, 0x2, 0xc6, 0xc1, 

+       0x3, 0x2, 0x2, 0x2, 0xc6, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc3, 0x3, 

+       0x2, 0x2, 0x2, 0xc6, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc5, 0x3, 0x2, 

+       0x2, 0x2, 0xc7, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xcf, 0x5, 0x32, 

+       0x1a, 0x2, 0xc9, 0xcf, 0x5, 0x3a, 0x1e, 0x2, 0xca, 0xcf, 0x5, 0x38, 

+       0x1d, 0x2, 0xcb, 0xcf, 0x5, 0x3c, 0x1f, 0x2, 0xcc, 0xcf, 0x5, 0x40, 

+       0x21, 0x2, 0xcd, 0xcf, 0x5, 0x34, 0x1b, 0x2, 0xce, 0xc8, 0x3, 0x2, 

+       0x2, 0x2, 0xce, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xce, 0xca, 0x3, 0x2, 0x2, 

+       0x2, 0xce, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcc, 0x3, 0x2, 0x2, 0x2, 

+       0xce, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x31, 0x3, 0x2, 0x2, 0x2, 0xd0, 

+       0xd1, 0x5, 0x42, 0x22, 0x2, 0xd1, 0xda, 0x7, 0x7, 0x2, 0x2, 0xd2, 

+       0xd7, 0x5, 0x2a, 0x16, 0x2, 0xd3, 0xd4, 0x7, 0x9, 0x2, 0x2, 0xd4, 

+       0xd6, 0x5, 0x2a, 0x16, 0x2, 0xd5, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xd6, 

+       0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, 

+       0x3, 0x2, 0x2, 0x2, 0xd8, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xd7, 0x3, 

+       0x2, 0x2, 0x2, 0xda, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, 

+       0x2, 0x2, 0xdb, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x8, 0x2, 

+       0x2, 0xdd, 0x33, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x5, 0x36, 0x1c, 

+       0x2, 0xdf, 0x35, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x5, 0x2c, 0x17, 

+       0x2, 0xe1, 0xe2, 0x7, 0x13, 0x2, 0x2, 0xe2, 0xe7, 0x5, 0x2c, 0x17, 

+       0x2, 0xe3, 0xe4, 0x7, 0x13, 0x2, 0x2, 0xe4, 0xe6, 0x5, 0x2c, 0x17, 

+       0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe9, 0x3, 0x2, 0x2, 0x2, 

+       0xe7, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, 

+       0x37, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, 

+       0x5, 0x44, 0x23, 0x2, 0xeb, 0x39, 0x3, 0x2, 0x2, 0x2, 0xec, 0xed, 

+       0x7, 0x14, 0x2, 0x2, 0xed, 0x3b, 0x3, 0x2, 0x2, 0x2, 0xee, 0xef, 

+       0x5, 0x2e, 0x18, 0x2, 0xef, 0xf0, 0x7, 0x10, 0x2, 0x2, 0xf0, 0xf1, 

+       0x5, 0x2a, 0x16, 0x2, 0xf1, 0xf2, 0x7, 0x11, 0x2, 0x2, 0xf2, 0x3d, 

+       0x3, 0x2, 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x38, 0x1d, 0x2, 0xf4, 0xf5, 

+       0x7, 0x12, 0x2, 0x2, 0xf5, 0xf6, 0x5, 0x38, 0x1d, 0x2, 0xf6, 0x3f, 

+       0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x7, 0x7, 0x2, 0x2, 0xf8, 0xf9, 0x5, 

+       0x2a, 0x16, 0x2, 0xf9, 0xfa, 0x7, 0x8, 0x2, 0x2, 0xfa, 0x41, 0x3, 

+       0x2, 0x2, 0x2, 0xfb, 0xfc, 0x7, 0x15, 0x2, 0x2, 0xfc, 0x43, 0x3, 

+       0x2, 0x2, 0x2, 0xfd, 0xfe, 0x7, 0x15, 0x2, 0x2, 0xfe, 0x45, 0x3, 

+       0x2, 0x2, 0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x47, 0x3, 

+       0x2, 0x2, 0x2, 0x101, 0x102, 0x7, 0x15, 0x2, 0x2, 0x102, 0x49, 0x3, 

+       0x2, 0x2, 0x2, 0x12, 0x4d, 0x54, 0x5f, 0x74, 0x77, 0x7d, 0x88, 0x8f, 

+       0x9b, 0xb7, 0xbf, 0xc6, 0xce, 0xd7, 0xda, 0xe7, 

   };

 

   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,