complete grammar

[toc] / gen / TocParser.cpp

diff --git a/gen/TocParser.cpp b/gen/TocParser.cpp
index eb6928d32b40fc0686cd0d6dda27e787b3ad642c..e1d5b1fce0dff33f084f07ec0d4599b83cf059d5 100644 (file)
--- a/gen/TocParser.cpp
+++ b/gen/TocParser.cpp
@@ -80,20 +80,20 @@ TocParser::ProgContext* TocParser::prog() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(73); \r
+    setState(81); \r

     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     do {\r
     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     do {\r

-      setState(72);\r
+      setState(80);\r

       decl();\r
       decl();\r

-      setState(75); \r
+      setState(83); \r

       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     } while ((((_la & ~ 0x3fULL) == 0) &&\r
       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r
       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     } while ((((_la & ~ 0x3fULL) == 0) &&\r
       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r

-      | (1ULL << TocParser::T__3)\r
-      | (1ULL << TocParser::T__9))) != 0));\r
-    setState(77);\r
+      | (1ULL << TocParser::T__6)\r
+      | (1ULL << TocParser::T__12))) != 0));\r
+    setState(85);\r

     match(TocParser::EOF);\r
    \r
   }\r
     match(TocParser::EOF);\r
    \r
   }\r


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

-    setState(82);\r
+    setState(90);\r

     _errHandler->sync(this);\r
     switch (_input->LA(1)) {\r
       case TocParser::T__0: {\r
         enterOuterAlt(_localctx, 1);\r
     _errHandler->sync(this);\r
     switch (_input->LA(1)) {\r
       case TocParser::T__0: {\r
         enterOuterAlt(_localctx, 1);\r

-        setState(79);\r
+        setState(87);\r

         varDecl();\r
         break;\r
       }\r
 \r
         varDecl();\r
         break;\r
       }\r
 \r

-      case TocParser::T__3: {\r
+      case TocParser::T__6: {\r

         enterOuterAlt(_localctx, 2);\r
         enterOuterAlt(_localctx, 2);\r

-        setState(80);\r
+        setState(88);\r

         funcDecl();\r
         break;\r
       }\r
 \r
         funcDecl();\r
         break;\r
       }\r
 \r

-      case TocParser::T__9: {\r
+      case TocParser::T__12: {\r

         enterOuterAlt(_localctx, 3);\r
         enterOuterAlt(_localctx, 3);\r

-        setState(81);\r
+        setState(89);\r

         structDecl();\r
         break;\r
       }\r
         structDecl();\r
         break;\r
       }\r


@@ -231,9 +231,9 @@ TocParser::VarDeclContext* TocParser::varDecl() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(84);\r
+    setState(92);\r

     match(TocParser::T__0);\r
     match(TocParser::T__0);\r

-    setState(85);\r
+    setState(93);\r

     var();\r
    \r
   }\r
     var();\r
    \r
   }\r


@@ -295,21 +295,21 @@ TocParser::VarContext* TocParser::var() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(87);\r
+    setState(95);\r

     varName();\r
 \r
     varName();\r
 \r

-    setState(88);\r
+    setState(96);\r

     match(TocParser::T__1);\r
     match(TocParser::T__1);\r

-    setState(89);\r
+    setState(97);\r

     type();\r
     type();\r

-    setState(93);\r
+    setState(101);\r

     _errHandler->sync(this);\r
 \r
     _la = _input->LA(1);\r
     if (_la == TocParser::T__2) {\r
     _errHandler->sync(this);\r
 \r
     _la = _input->LA(1);\r
     if (_la == TocParser::T__2) {\r

-      setState(91);\r
+      setState(99);\r

       match(TocParser::T__2);\r
       match(TocParser::T__2);\r

-      setState(92);\r
+      setState(100);\r

       expr();\r
     }\r
    \r
       expr();\r
     }\r
    \r


@@ -323,6 +323,77 @@ TocParser::VarContext* TocParser::var() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

+//----------------- VarInitContext ------------------------------------------------------------------\r
+\r
+TocParser::VarInitContext::VarInitContext(ParserRuleContext *parent, size_t invokingState)\r
+  : ParserRuleContext(parent, invokingState) {\r
+}\r
+\r
+TocParser::VarNameContext* TocParser::VarInitContext::varName() {\r
+  return getRuleContext<TocParser::VarNameContext>(0);\r
+}\r
+\r
+TocParser::TypeContext* TocParser::VarInitContext::type() {\r
+  return getRuleContext<TocParser::TypeContext>(0);\r
+}\r
+\r
+TocParser::ExprContext* TocParser::VarInitContext::expr() {\r
+  return getRuleContext<TocParser::ExprContext>(0);\r
+}\r
+\r
+\r
+size_t TocParser::VarInitContext::getRuleIndex() const {\r
+  return TocParser::RuleVarInit;\r
+}\r
+\r
+void TocParser::VarInitContext::enterRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->enterVarInit(this);\r
+}\r
+\r
+void TocParser::VarInitContext::exitRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->exitVarInit(this);\r
+}\r
+\r
+TocParser::VarInitContext* TocParser::varInit() {\r
+  VarInitContext *_localctx = _tracker.createInstance<VarInitContext>(_ctx, getState());\r
+  enterRule(_localctx, 8, TocParser::RuleVarInit);\r
+\r
+#if __cplusplus > 201703L\r
+  auto onExit = finally([=, this] {\r
+#else\r
+  auto onExit = finally([=] {\r
+#endif\r
+    exitRule();\r
+  });\r
+  try {\r
+    enterOuterAlt(_localctx, 1);\r
+    setState(103);\r
+    varName();\r
+\r
+    setState(104);\r
+    match(TocParser::T__1);\r
+    setState(105);\r
+    type();\r
+\r
+    setState(107);\r
+    match(TocParser::T__2);\r
+    setState(108);\r
+    expr();\r
+   \r
+  }\r
+  catch (RecognitionException &e) {\r
+    _errHandler->reportError(this, e);\r
+    _localctx->exception = std::current_exception();\r
+    _errHandler->recover(this, _localctx->exception);\r
+  }\r
+\r
+  return _localctx;\r
+}\r
+\r

 //----------------- TypeContext ------------------------------------------------------------------\r
 \r
 TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)\r
 //----------------- TypeContext ------------------------------------------------------------------\r
 \r
 TocParser::TypeContext::TypeContext(ParserRuleContext *parent, size_t invokingState)\r


@@ -333,6 +404,14 @@ TocParser::TypeNameContext* TocParser::TypeContext::typeName() {
   return getRuleContext<TocParser::TypeNameContext>(0);\r
 }\r
 \r
   return getRuleContext<TocParser::TypeNameContext>(0);\r
 }\r
 \r

+std::vector<TocParser::TypeModifierContext *> TocParser::TypeContext::typeModifier() {\r
+  return getRuleContexts<TocParser::TypeModifierContext>();\r
+}\r
+\r
+TocParser::TypeModifierContext* TocParser::TypeContext::typeModifier(size_t i) {\r
+  return getRuleContext<TocParser::TypeModifierContext>(i);\r
+}\r
+\r

 \r
 size_t TocParser::TypeContext::getRuleIndex() const {\r
   return TocParser::RuleType;\r
 \r
 size_t TocParser::TypeContext::getRuleIndex() const {\r
   return TocParser::RuleType;\r


@@ -352,7 +431,8 @@ void TocParser::TypeContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::TypeContext* TocParser::type() {\r
   TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());\r
 \r
 TocParser::TypeContext* TocParser::type() {\r
   TypeContext *_localctx = _tracker.createInstance<TypeContext>(_ctx, getState());\r

-  enterRule(_localctx, 8, TocParser::RuleType);\r
+  enterRule(_localctx, 10, TocParser::RuleType);\r
+  size_t _la = 0;\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -363,8 +443,101 @@ TocParser::TypeContext* TocParser::type() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(95);\r
+    setState(110);\r

     typeName();\r
     typeName();\r

+    setState(114);\r
+    _errHandler->sync(this);\r
+    _la = _input->LA(1);\r
+    while (_la == TocParser::T__3\r
+\r
+    || _la == TocParser::T__4) {\r
+      setState(111);\r
+      typeModifier();\r
+      setState(116);\r
+      _errHandler->sync(this);\r
+      _la = _input->LA(1);\r
+    }\r
+   \r
+  }\r
+  catch (RecognitionException &e) {\r
+    _errHandler->reportError(this, e);\r
+    _localctx->exception = std::current_exception();\r
+    _errHandler->recover(this, _localctx->exception);\r
+  }\r
+\r
+  return _localctx;\r
+}\r
+\r
+//----------------- TypeModifierContext ------------------------------------------------------------------\r
+\r
+TocParser::TypeModifierContext::TypeModifierContext(ParserRuleContext *parent, size_t invokingState)\r
+  : ParserRuleContext(parent, invokingState) {\r
+}\r
+\r
+tree::TerminalNode* TocParser::TypeModifierContext::NUMBER() {\r
+  return getToken(TocParser::NUMBER, 0);\r
+}\r
+\r
+\r
+size_t TocParser::TypeModifierContext::getRuleIndex() const {\r
+  return TocParser::RuleTypeModifier;\r
+}\r
+\r
+void TocParser::TypeModifierContext::enterRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->enterTypeModifier(this);\r
+}\r
+\r
+void TocParser::TypeModifierContext::exitRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->exitTypeModifier(this);\r
+}\r
+\r
+TocParser::TypeModifierContext* TocParser::typeModifier() {\r
+  TypeModifierContext *_localctx = _tracker.createInstance<TypeModifierContext>(_ctx, getState());\r
+  enterRule(_localctx, 12, TocParser::RuleTypeModifier);\r
+  size_t _la = 0;\r
+\r
+#if __cplusplus > 201703L\r
+  auto onExit = finally([=, this] {\r
+#else\r
+  auto onExit = finally([=] {\r
+#endif\r
+    exitRule();\r
+  });\r
+  try {\r
+    setState(123);\r
+    _errHandler->sync(this);\r
+    switch (_input->LA(1)) {\r
+      case TocParser::T__3: {\r
+        enterOuterAlt(_localctx, 1);\r
+        setState(117);\r
+        match(TocParser::T__3);\r
+        break;\r
+      }\r
+\r
+      case TocParser::T__4: {\r
+        enterOuterAlt(_localctx, 2);\r
+        setState(118);\r
+        match(TocParser::T__4);\r
+        setState(120);\r
+        _errHandler->sync(this);\r
+\r
+        _la = _input->LA(1);\r
+        if (_la == TocParser::NUMBER) {\r
+          setState(119);\r
+          match(TocParser::NUMBER);\r
+        }\r
+        setState(122);\r
+        match(TocParser::T__5);\r
+        break;\r
+      }\r
+\r
+    default:\r
+      throw NoViableAltException(this);\r
+    }\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -405,7 +578,7 @@ void TocParser::FuncDeclContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::FuncDeclContext* TocParser::funcDecl() {\r
   FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());\r
 \r
 TocParser::FuncDeclContext* TocParser::funcDecl() {\r
   FuncDeclContext *_localctx = _tracker.createInstance<FuncDeclContext>(_ctx, getState());\r

-  enterRule(_localctx, 10, TocParser::RuleFuncDecl);\r
+  enterRule(_localctx, 14, TocParser::RuleFuncDecl);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -416,9 +589,9 @@ TocParser::FuncDeclContext* TocParser::funcDecl() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(97);\r
-    match(TocParser::T__3);\r
-    setState(98);\r
+    setState(125);\r
+    match(TocParser::T__6);\r
+    setState(126);\r

     func();\r
    \r
   }\r
     func();\r
    \r
   }\r


@@ -472,7 +645,7 @@ void TocParser::FuncContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::FuncContext* TocParser::func() {\r
   FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());\r
 \r
 TocParser::FuncContext* TocParser::func() {\r
   FuncContext *_localctx = _tracker.createInstance<FuncContext>(_ctx, getState());\r

-  enterRule(_localctx, 12, TocParser::RuleFunc);\r
+  enterRule(_localctx, 16, TocParser::RuleFunc);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -483,20 +656,20 @@ TocParser::FuncContext* TocParser::func() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(100);\r
+    setState(128);\r

     funcName();\r
     funcName();\r

-    setState(101);\r
-    match(TocParser::T__4);\r
-    setState(102);\r
+    setState(129);\r
+    match(TocParser::T__7);\r
+    setState(130);\r

     parameter();\r
     parameter();\r

-    setState(103);\r
-    match(TocParser::T__5);\r
+    setState(131);\r
+    match(TocParser::T__8);\r

 \r
 \r

-    setState(104);\r
+    setState(132);\r

     match(TocParser::T__1);\r
     match(TocParser::T__1);\r

-    setState(105);\r
+    setState(133);\r

     type();\r
     type();\r

-    setState(107);\r
+    setState(135);\r

     body();\r
    \r
   }\r
     body();\r
    \r
   }\r


@@ -542,7 +715,7 @@ void TocParser::ParameterContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::ParameterContext* TocParser::parameter() {\r
   ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());\r
 \r
 TocParser::ParameterContext* TocParser::parameter() {\r
   ParameterContext *_localctx = _tracker.createInstance<ParameterContext>(_ctx, getState());\r

-  enterRule(_localctx, 14, TocParser::RuleParameter);\r
+  enterRule(_localctx, 18, TocParser::RuleParameter);\r

   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r
   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r


@@ -554,22 +727,22 @@ TocParser::ParameterContext* TocParser::parameter() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(117);\r
+    setState(145);\r

     _errHandler->sync(this);\r
 \r
     _la = _input->LA(1);\r
     if (_la == TocParser::NAME) {\r
     _errHandler->sync(this);\r
 \r
     _la = _input->LA(1);\r
     if (_la == TocParser::NAME) {\r

-      setState(109);\r
+      setState(137);\r

       var();\r
       var();\r

-      setState(114);\r
+      setState(142);\r

       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
       _errHandler->sync(this);\r
       _la = _input->LA(1);\r

-      while (_la == TocParser::T__6) {\r
-        setState(110);\r
-        match(TocParser::T__6);\r
-        setState(111);\r
+      while (_la == TocParser::T__9) {\r
+        setState(138);\r
+        match(TocParser::T__9);\r
+        setState(139);\r

         var();\r
         var();\r

-        setState(116);\r
+        setState(144);\r

         _errHandler->sync(this);\r
         _la = _input->LA(1);\r
       }\r
         _errHandler->sync(this);\r
         _la = _input->LA(1);\r
       }\r


@@ -618,7 +791,7 @@ void TocParser::BodyContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::BodyContext* TocParser::body() {\r
   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());\r
 \r
 TocParser::BodyContext* TocParser::body() {\r
   BodyContext *_localctx = _tracker.createInstance<BodyContext>(_ctx, getState());\r

-  enterRule(_localctx, 16, TocParser::RuleBody);\r
+  enterRule(_localctx, 20, TocParser::RuleBody);\r

   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r
   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r


@@ -630,27 +803,33 @@ TocParser::BodyContext* TocParser::body() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(119);\r
-    match(TocParser::T__7);\r
-    setState(123);\r
+    setState(147);\r
+    match(TocParser::T__10);\r
+    setState(151);\r

     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     while ((((_la & ~ 0x3fULL) == 0) &&\r
       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r
     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     while ((((_la & ~ 0x3fULL) == 0) &&\r
       ((1ULL << _la) & ((1ULL << TocParser::T__0)\r

-      | (1ULL << TocParser::T__4)\r
-      | (1ULL << TocParser::T__10)\r
-      | (1ULL << TocParser::T__11)\r
-      | (1ULL << TocParser::T__12)\r
-      | (1ULL << TocParser::INTLIT)\r
+      | (1ULL << TocParser::T__7)\r
+      | (1ULL << TocParser::T__13)\r
+      | (1ULL << TocParser::T__15)\r
+      | (1ULL << TocParser::T__17)\r
+      | (1ULL << TocParser::T__18)\r
+      | (1ULL << TocParser::T__19)\r
+      | (1ULL << TocParser::PREFIX_OP)\r
+      | (1ULL << TocParser::INT_LIT)\r
+      | (1ULL << TocParser::DECIMAL_LIT)\r
+      | (1ULL << TocParser::STRING_LIT)\r
+      | (1ULL << TocParser::BOOL_LIT)\r

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

-      setState(120);\r
+      setState(148);\r

       stmt();\r
       stmt();\r

-      setState(125);\r
+      setState(153);\r

       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     }\r
       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     }\r

-    setState(126);\r
-    match(TocParser::T__8);\r
+    setState(154);\r
+    match(TocParser::T__11);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -699,7 +878,7 @@ void TocParser::StructDeclContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::StructDeclContext* TocParser::structDecl() {\r
   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());\r
 \r
 TocParser::StructDeclContext* TocParser::structDecl() {\r
   StructDeclContext *_localctx = _tracker.createInstance<StructDeclContext>(_ctx, getState());\r

-  enterRule(_localctx, 18, TocParser::RuleStructDecl);\r
+  enterRule(_localctx, 22, TocParser::RuleStructDecl);\r

   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r
   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r


@@ -711,24 +890,24 @@ TocParser::StructDeclContext* TocParser::structDecl() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(128);\r
-    match(TocParser::T__9);\r
-    setState(129);\r
+    setState(156);\r
+    match(TocParser::T__12);\r
+    setState(157);\r

     structName();\r
     structName();\r

-    setState(130);\r
-    match(TocParser::T__7);\r
-    setState(134);\r
+    setState(158);\r
+    match(TocParser::T__10);\r
+    setState(162);\r

     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     while (_la == TocParser::NAME) {\r
     _errHandler->sync(this);\r
     _la = _input->LA(1);\r
     while (_la == TocParser::NAME) {\r

-      setState(131);\r
+      setState(159);\r

       structMember();\r
       structMember();\r

-      setState(136);\r
+      setState(164);\r

       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     }\r
       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
     }\r

-    setState(137);\r
-    match(TocParser::T__8);\r
+    setState(165);\r
+    match(TocParser::T__11);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -773,7 +952,7 @@ void TocParser::StructMemberContext::exitRule(tree::ParseTreeListener *listener)
 \r
 TocParser::StructMemberContext* TocParser::structMember() {\r
   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());\r
 \r
 TocParser::StructMemberContext* TocParser::structMember() {\r
   StructMemberContext *_localctx = _tracker.createInstance<StructMemberContext>(_ctx, getState());\r

-  enterRule(_localctx, 20, TocParser::RuleStructMember);\r
+  enterRule(_localctx, 24, TocParser::RuleStructMember);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -783,19 +962,19 @@ TocParser::StructMemberContext* TocParser::structMember() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    setState(141);\r
+    setState(169);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
       enterOuterAlt(_localctx, 1);\r
     case 1: {\r
       enterOuterAlt(_localctx, 1);\r

-      setState(139);\r
+      setState(167);\r

       structVar();\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r
       structVar();\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r

-      setState(140);\r
+      setState(168);\r

       structMethod();\r
       break;\r
     }\r
       structMethod();\r
       break;\r
     }\r


@@ -843,7 +1022,7 @@ void TocParser::StructVarContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::StructVarContext* TocParser::structVar() {\r
   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());\r
 \r
 TocParser::StructVarContext* TocParser::structVar() {\r
   StructVarContext *_localctx = _tracker.createInstance<StructVarContext>(_ctx, getState());\r

-  enterRule(_localctx, 22, TocParser::RuleStructVar);\r
+  enterRule(_localctx, 26, TocParser::RuleStructVar);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -854,7 +1033,7 @@ TocParser::StructVarContext* TocParser::structVar() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(143);\r
+    setState(171);\r

     var();\r
    \r
   }\r
     var();\r
    \r
   }\r


@@ -896,7 +1075,7 @@ void TocParser::StructMethodContext::exitRule(tree::ParseTreeListener *listener)
 \r
 TocParser::StructMethodContext* TocParser::structMethod() {\r
   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());\r
 \r
 TocParser::StructMethodContext* TocParser::structMethod() {\r
   StructMethodContext *_localctx = _tracker.createInstance<StructMethodContext>(_ctx, getState());\r

-  enterRule(_localctx, 24, TocParser::RuleStructMethod);\r
+  enterRule(_localctx, 28, TocParser::RuleStructMethod);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -907,7 +1086,7 @@ TocParser::StructMethodContext* TocParser::structMethod() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(145);\r
+    setState(173);\r

     func();\r
    \r
   }\r
     func();\r
    \r
   }\r


@@ -930,16 +1109,24 @@ TocParser::VarDeclContext* TocParser::StmtContext::varDecl() {
   return getRuleContext<TocParser::VarDeclContext>(0);\r
 }\r
 \r
   return getRuleContext<TocParser::VarDeclContext>(0);\r
 }\r
 \r

-TocParser::ConditionalContext* TocParser::StmtContext::conditional() {\r
-  return getRuleContext<TocParser::ConditionalContext>(0);\r
+TocParser::IfStmtContext* TocParser::StmtContext::ifStmt() {\r
+  return getRuleContext<TocParser::IfStmtContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::LoopContext* TocParser::StmtContext::loop() {\r
-  return getRuleContext<TocParser::LoopContext>(0);\r
+TocParser::SwitchStmtContext* TocParser::StmtContext::switchStmt() {\r
+  return getRuleContext<TocParser::SwitchStmtContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::AssignmentContext* TocParser::StmtContext::assignment() {\r
-  return getRuleContext<TocParser::AssignmentContext>(0);\r
+TocParser::ForStmtContext* TocParser::StmtContext::forStmt() {\r
+  return getRuleContext<TocParser::ForStmtContext>(0);\r
+}\r
+\r
+TocParser::WhileStmtContext* TocParser::StmtContext::whileStmt() {\r
+  return getRuleContext<TocParser::WhileStmtContext>(0);\r
+}\r
+\r
+TocParser::AssignStmtContext* TocParser::StmtContext::assignStmt() {\r
+  return getRuleContext<TocParser::AssignStmtContext>(0);\r

 }\r
 \r
 TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {\r
 }\r
 \r
 TocParser::ReturnStmtContext* TocParser::StmtContext::returnStmt() {\r


@@ -969,7 +1156,7 @@ void TocParser::StmtContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::StmtContext* TocParser::stmt() {\r
   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());\r
 \r
 TocParser::StmtContext* TocParser::stmt() {\r
   StmtContext *_localctx = _tracker.createInstance<StmtContext>(_ctx, getState());\r

-  enterRule(_localctx, 26, TocParser::RuleStmt);\r
+  enterRule(_localctx, 30, TocParser::RuleStmt);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -979,42 +1166,61 @@ TocParser::StmtContext* TocParser::stmt() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    enterOuterAlt(_localctx, 1);\r
-    setState(153);\r
+    setState(183);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
     case 1: {\r

-      setState(147);\r
+      enterOuterAlt(_localctx, 1);\r
+      setState(175);\r

       varDecl();\r
       break;\r
     }\r
 \r
     case 2: {\r
       varDecl();\r
       break;\r
     }\r
 \r
     case 2: {\r

-      setState(148);\r
-      conditional();\r
+      enterOuterAlt(_localctx, 2);\r
+      setState(176);\r
+      ifStmt();\r

       break;\r
     }\r
 \r
     case 3: {\r
       break;\r
     }\r
 \r
     case 3: {\r

-      setState(149);\r
-      loop();\r
+      enterOuterAlt(_localctx, 3);\r
+      setState(177);\r
+      switchStmt();\r

       break;\r
     }\r
 \r
     case 4: {\r
       break;\r
     }\r
 \r
     case 4: {\r

-      setState(150);\r
-      assignment();\r
+      enterOuterAlt(_localctx, 4);\r
+      setState(178);\r
+      forStmt();\r

       break;\r
     }\r
 \r
     case 5: {\r
       break;\r
     }\r
 \r
     case 5: {\r

-      setState(151);\r
-      returnStmt();\r
+      enterOuterAlt(_localctx, 5);\r
+      setState(179);\r
+      whileStmt();\r

       break;\r
     }\r
 \r
     case 6: {\r
       break;\r
     }\r
 \r
     case 6: {\r

-      setState(152);\r
+      enterOuterAlt(_localctx, 6);\r
+      setState(180);\r
+      assignStmt();\r
+      break;\r
+    }\r
+\r
+    case 7: {\r
+      enterOuterAlt(_localctx, 7);\r
+      setState(181);\r
+      returnStmt();\r
+      break;\r
+    }\r
+\r
+    case 8: {\r
+      enterOuterAlt(_localctx, 8);\r
+      setState(182);\r

       expr();\r
       break;\r
     }\r
       expr();\r
       break;\r
     }\r


@@ -1033,36 +1239,49 @@ TocParser::StmtContext* TocParser::stmt() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- ConditionalContext ------------------------------------------------------------------\r
+//----------------- IfStmtContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::ConditionalContext::ConditionalContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::IfStmtContext::IfStmtContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::IfCondContext* TocParser::ConditionalContext::ifCond() {\r
-  return getRuleContext<TocParser::IfCondContext>(0);\r
+std::vector<TocParser::ExprContext *> TocParser::IfStmtContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r
+}\r
+\r
+TocParser::ExprContext* TocParser::IfStmtContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r
+}\r
+\r
+std::vector<TocParser::BodyContext *> TocParser::IfStmtContext::body() {\r
+  return getRuleContexts<TocParser::BodyContext>();\r
+}\r
+\r
+TocParser::BodyContext* TocParser::IfStmtContext::body(size_t i) {\r
+  return getRuleContext<TocParser::BodyContext>(i);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::ConditionalContext::getRuleIndex() const {\r
-  return TocParser::RuleConditional;\r
+size_t TocParser::IfStmtContext::getRuleIndex() const {\r
+  return TocParser::RuleIfStmt;\r

 }\r
 \r
 }\r
 \r

-void TocParser::ConditionalContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::IfStmtContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterConditional(this);\r
+    parserListener->enterIfStmt(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::ConditionalContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::IfStmtContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitConditional(this);\r
+    parserListener->exitIfStmt(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::ConditionalContext* TocParser::conditional() {\r
-  ConditionalContext *_localctx = _tracker.createInstance<ConditionalContext>(_ctx, getState());\r
-  enterRule(_localctx, 28, TocParser::RuleConditional);\r
+TocParser::IfStmtContext* TocParser::ifStmt() {\r
+  IfStmtContext *_localctx = _tracker.createInstance<IfStmtContext>(_ctx, getState());\r
+  enterRule(_localctx, 32, TocParser::RuleIfStmt);\r
+  size_t _la = 0;\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1072,9 +1291,42 @@ TocParser::ConditionalContext* TocParser::conditional() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

+    size_t alt;\r

     enterOuterAlt(_localctx, 1);\r
     enterOuterAlt(_localctx, 1);\r

-    setState(155);\r
-    ifCond();\r
+    setState(185);\r
+    match(TocParser::T__13);\r
+    setState(186);\r
+    expr();\r
+    setState(187);\r
+    body();\r
+    setState(195);\r
+    _errHandler->sync(this);\r
+    alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);\r
+    while (alt != 2 && alt != atn::ATN::INVALID_ALT_NUMBER) {\r
+      if (alt == 1) {\r
+        setState(188);\r
+        match(TocParser::T__14);\r
+        setState(189);\r
+        match(TocParser::T__13);\r
+        setState(190);\r
+        expr();\r
+        setState(191);\r
+        body(); \r
+      }\r
+      setState(197);\r
+      _errHandler->sync(this);\r
+      alt = getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 12, _ctx);\r
+    }\r
+    setState(200);\r
+    _errHandler->sync(this);\r
+\r
+    _la = _input->LA(1);\r
+    if (_la == TocParser::T__14) {\r
+      setState(198);\r
+      match(TocParser::T__14);\r
+      setState(199);\r
+      body();\r
+    }\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -1086,40 +1338,40 @@ TocParser::ConditionalContext* TocParser::conditional() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- IfCondContext ------------------------------------------------------------------\r
+//----------------- SwitchStmtContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::IfCondContext::IfCondContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::SwitchStmtContext::SwitchStmtContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::ExprContext* TocParser::IfCondContext::expr() {\r
-  return getRuleContext<TocParser::ExprContext>(0);\r
+TocParser::IdentifierExprContext* TocParser::SwitchStmtContext::identifierExpr() {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::BodyContext* TocParser::IfCondContext::body() {\r
-  return getRuleContext<TocParser::BodyContext>(0);\r
+TocParser::SwitchBodyContext* TocParser::SwitchStmtContext::switchBody() {\r
+  return getRuleContext<TocParser::SwitchBodyContext>(0);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::IfCondContext::getRuleIndex() const {\r
-  return TocParser::RuleIfCond;\r
+size_t TocParser::SwitchStmtContext::getRuleIndex() const {\r
+  return TocParser::RuleSwitchStmt;\r

 }\r
 \r
 }\r
 \r

-void TocParser::IfCondContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::SwitchStmtContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterIfCond(this);\r
+    parserListener->enterSwitchStmt(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::IfCondContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::SwitchStmtContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitIfCond(this);\r
+    parserListener->exitSwitchStmt(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::IfCondContext* TocParser::ifCond() {\r
-  IfCondContext *_localctx = _tracker.createInstance<IfCondContext>(_ctx, getState());\r
-  enterRule(_localctx, 30, TocParser::RuleIfCond);\r
+TocParser::SwitchStmtContext* TocParser::switchStmt() {\r
+  SwitchStmtContext *_localctx = _tracker.createInstance<SwitchStmtContext>(_ctx, getState());\r
+  enterRule(_localctx, 34, TocParser::RuleSwitchStmt);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1130,12 +1382,12 @@ TocParser::IfCondContext* TocParser::ifCond() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(157);\r
-    match(TocParser::T__10);\r
-    setState(158);\r
-    expr();\r
-    setState(159);\r
-    body();\r
+    setState(202);\r
+    match(TocParser::T__15);\r
+    setState(203);\r
+    identifierExpr();\r
+    setState(204);\r
+    switchBody();\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -1147,36 +1399,49 @@ TocParser::IfCondContext* TocParser::ifCond() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- LoopContext ------------------------------------------------------------------\r
+//----------------- SwitchBodyContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::LoopContext::LoopContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::SwitchBodyContext::SwitchBodyContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::WhileLoopContext* TocParser::LoopContext::whileLoop() {\r
-  return getRuleContext<TocParser::WhileLoopContext>(0);\r
+std::vector<TocParser::ExprContext *> TocParser::SwitchBodyContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r
+}\r
+\r
+TocParser::ExprContext* TocParser::SwitchBodyContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r
+}\r
+\r
+std::vector<TocParser::BodyContext *> TocParser::SwitchBodyContext::body() {\r
+  return getRuleContexts<TocParser::BodyContext>();\r
+}\r
+\r
+TocParser::BodyContext* TocParser::SwitchBodyContext::body(size_t i) {\r
+  return getRuleContext<TocParser::BodyContext>(i);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::LoopContext::getRuleIndex() const {\r
-  return TocParser::RuleLoop;\r
+size_t TocParser::SwitchBodyContext::getRuleIndex() const {\r
+  return TocParser::RuleSwitchBody;\r

 }\r
 \r
 }\r
 \r

-void TocParser::LoopContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::SwitchBodyContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterLoop(this);\r
+    parserListener->enterSwitchBody(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::LoopContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::SwitchBodyContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitLoop(this);\r
+    parserListener->exitSwitchBody(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::LoopContext* TocParser::loop() {\r
-  LoopContext *_localctx = _tracker.createInstance<LoopContext>(_ctx, getState());\r
-  enterRule(_localctx, 32, TocParser::RuleLoop);\r
+TocParser::SwitchBodyContext* TocParser::switchBody() {\r
+  SwitchBodyContext *_localctx = _tracker.createInstance<SwitchBodyContext>(_ctx, getState());\r
+  enterRule(_localctx, 36, TocParser::RuleSwitchBody);\r
+  size_t _la = 0;\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1187,8 +1452,24 @@ TocParser::LoopContext* TocParser::loop() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(161);\r
-    whileLoop();\r
+    setState(206);\r
+    match(TocParser::T__10);\r
+    setState(213);\r
+    _errHandler->sync(this);\r
+    _la = _input->LA(1);\r
+    while (_la == TocParser::T__16) {\r
+      setState(207);\r
+      match(TocParser::T__16);\r
+      setState(208);\r
+      expr();\r
+      setState(209);\r
+      body();\r
+      setState(215);\r
+      _errHandler->sync(this);\r
+      _la = _input->LA(1);\r
+    }\r
+    setState(216);\r
+    match(TocParser::T__11);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -1200,40 +1481,52 @@ TocParser::LoopContext* TocParser::loop() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- WhileLoopContext ------------------------------------------------------------------\r
+//----------------- ForStmtContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::WhileLoopContext::WhileLoopContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::ForStmtContext::ForStmtContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::ExprContext* TocParser::WhileLoopContext::expr() {\r
-  return getRuleContext<TocParser::ExprContext>(0);\r
+std::vector<TocParser::ExprContext *> TocParser::ForStmtContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r
+}\r
+\r
+TocParser::ExprContext* TocParser::ForStmtContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r

 }\r
 \r
 }\r
 \r

-TocParser::BodyContext* TocParser::WhileLoopContext::body() {\r
+TocParser::BodyContext* TocParser::ForStmtContext::body() {\r

   return getRuleContext<TocParser::BodyContext>(0);\r
 }\r
 \r
   return getRuleContext<TocParser::BodyContext>(0);\r
 }\r
 \r

+TocParser::VarInitContext* TocParser::ForStmtContext::varInit() {\r
+  return getRuleContext<TocParser::VarInitContext>(0);\r
+}\r

 \r
 \r

-size_t TocParser::WhileLoopContext::getRuleIndex() const {\r
-  return TocParser::RuleWhileLoop;\r
+TocParser::AssignStmtContext* TocParser::ForStmtContext::assignStmt() {\r
+  return getRuleContext<TocParser::AssignStmtContext>(0);\r

 }\r
 \r
 }\r
 \r

-void TocParser::WhileLoopContext::enterRule(tree::ParseTreeListener *listener) {\r
-  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+\r
+size_t TocParser::ForStmtContext::getRuleIndex() const {\r
+  return TocParser::RuleForStmt;\r
+}\r
+\r
+void TocParser::ForStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r

   if (parserListener != nullptr)\r
   if (parserListener != nullptr)\r

-    parserListener->enterWhileLoop(this);\r
+    parserListener->enterForStmt(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::WhileLoopContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::ForStmtContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitWhileLoop(this);\r
+    parserListener->exitForStmt(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::WhileLoopContext* TocParser::whileLoop() {\r
-  WhileLoopContext *_localctx = _tracker.createInstance<WhileLoopContext>(_ctx, getState());\r
-  enterRule(_localctx, 34, TocParser::RuleWhileLoop);\r
+TocParser::ForStmtContext* TocParser::forStmt() {\r
+  ForStmtContext *_localctx = _tracker.createInstance<ForStmtContext>(_ctx, getState());\r
+  enterRule(_localctx, 38, TocParser::RuleForStmt);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1244,11 +1537,35 @@ TocParser::WhileLoopContext* TocParser::whileLoop() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(163);\r
-    match(TocParser::T__11);\r
-    setState(164);\r
+    setState(218);\r
+    match(TocParser::T__17);\r
+    setState(221);\r
+    _errHandler->sync(this);\r
+    switch (getInterpreter<atn::ParserATNSimulator>()->adaptivePredict(_input, 15, _ctx)) {\r
+    case 1: {\r
+      setState(219);\r
+      varInit();\r
+      break;\r
+    }\r
+\r
+    case 2: {\r
+      setState(220);\r
+      assignStmt();\r
+      break;\r
+    }\r
+\r
+    default:\r
+      break;\r
+    }\r
+    setState(223);\r
+    match(TocParser::T__9);\r
+    setState(224);\r

     expr();\r
     expr();\r

-    setState(165);\r
+    setState(225);\r
+    match(TocParser::T__9);\r
+    setState(226);\r
+    expr();\r
+    setState(227);\r

     body();\r
    \r
   }\r
     body();\r
    \r
   }\r


@@ -1261,40 +1578,101 @@ TocParser::WhileLoopContext* TocParser::whileLoop() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- AssignmentContext ------------------------------------------------------------------\r
+//----------------- WhileStmtContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::AssignmentContext::AssignmentContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::WhileStmtContext::WhileStmtContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::IdentifierContext* TocParser::AssignmentContext::identifier() {\r
-  return getRuleContext<TocParser::IdentifierContext>(0);\r
+TocParser::ExprContext* TocParser::WhileStmtContext::expr() {\r
+  return getRuleContext<TocParser::ExprContext>(0);\r
+}\r
+\r
+TocParser::BodyContext* TocParser::WhileStmtContext::body() {\r
+  return getRuleContext<TocParser::BodyContext>(0);\r
+}\r
+\r
+\r
+size_t TocParser::WhileStmtContext::getRuleIndex() const {\r
+  return TocParser::RuleWhileStmt;\r
+}\r
+\r
+void TocParser::WhileStmtContext::enterRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->enterWhileStmt(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::ExprContext* TocParser::AssignmentContext::expr() {\r
+void TocParser::WhileStmtContext::exitRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->exitWhileStmt(this);\r
+}\r
+\r
+TocParser::WhileStmtContext* TocParser::whileStmt() {\r
+  WhileStmtContext *_localctx = _tracker.createInstance<WhileStmtContext>(_ctx, getState());\r
+  enterRule(_localctx, 40, TocParser::RuleWhileStmt);\r
+\r
+#if __cplusplus > 201703L\r
+  auto onExit = finally([=, this] {\r
+#else\r
+  auto onExit = finally([=] {\r
+#endif\r
+    exitRule();\r
+  });\r
+  try {\r
+    enterOuterAlt(_localctx, 1);\r
+    setState(229);\r
+    match(TocParser::T__18);\r
+    setState(230);\r
+    expr();\r
+    setState(231);\r
+    body();\r
+   \r
+  }\r
+  catch (RecognitionException &e) {\r
+    _errHandler->reportError(this, e);\r
+    _localctx->exception = std::current_exception();\r
+    _errHandler->recover(this, _localctx->exception);\r
+  }\r
+\r
+  return _localctx;\r
+}\r
+\r
+//----------------- AssignStmtContext ------------------------------------------------------------------\r
+\r
+TocParser::AssignStmtContext::AssignStmtContext(ParserRuleContext *parent, size_t invokingState)\r
+  : ParserRuleContext(parent, invokingState) {\r
+}\r
+\r
+TocParser::IdentifierExprContext* TocParser::AssignStmtContext::identifierExpr() {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(0);\r
+}\r
+\r
+TocParser::ExprContext* TocParser::AssignStmtContext::expr() {\r

   return getRuleContext<TocParser::ExprContext>(0);\r
 }\r
 \r
 \r
   return getRuleContext<TocParser::ExprContext>(0);\r
 }\r
 \r
 \r

-size_t TocParser::AssignmentContext::getRuleIndex() const {\r
-  return TocParser::RuleAssignment;\r
+size_t TocParser::AssignStmtContext::getRuleIndex() const {\r
+  return TocParser::RuleAssignStmt;\r

 }\r
 \r
 }\r
 \r

-void TocParser::AssignmentContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::AssignStmtContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterAssignment(this);\r
+    parserListener->enterAssignStmt(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::AssignmentContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::AssignStmtContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitAssignment(this);\r
+    parserListener->exitAssignStmt(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::AssignmentContext* TocParser::assignment() {\r
-  AssignmentContext *_localctx = _tracker.createInstance<AssignmentContext>(_ctx, getState());\r
-  enterRule(_localctx, 36, TocParser::RuleAssignment);\r
+TocParser::AssignStmtContext* TocParser::assignStmt() {\r
+  AssignStmtContext *_localctx = _tracker.createInstance<AssignStmtContext>(_ctx, getState());\r
+  enterRule(_localctx, 42, TocParser::RuleAssignStmt);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1305,11 +1683,11 @@ TocParser::AssignmentContext* TocParser::assignment() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(167);\r
-    identifier();\r
-    setState(168);\r
+    setState(233);\r
+    identifierExpr();\r
+    setState(234);\r

     match(TocParser::T__2);\r
     match(TocParser::T__2);\r

-    setState(169);\r
+    setState(235);\r

     expr();\r
    \r
   }\r
     expr();\r
    \r
   }\r


@@ -1351,7 +1729,7 @@ void TocParser::ReturnStmtContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::ReturnStmtContext* TocParser::returnStmt() {\r
   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());\r
 \r
 TocParser::ReturnStmtContext* TocParser::returnStmt() {\r
   ReturnStmtContext *_localctx = _tracker.createInstance<ReturnStmtContext>(_ctx, getState());\r

-  enterRule(_localctx, 38, TocParser::RuleReturnStmt);\r
+  enterRule(_localctx, 44, TocParser::RuleReturnStmt);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1362,9 +1740,9 @@ TocParser::ReturnStmtContext* TocParser::returnStmt() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(171);\r
-    match(TocParser::T__12);\r
-    setState(172);\r
+    setState(237);\r
+    match(TocParser::T__19);\r
+    setState(238);\r

     expr();\r
    \r
   }\r
     expr();\r
    \r
   }\r


@@ -1383,32 +1761,28 @@ TocParser::ExprContext::ExprContext(ParserRuleContext *parent, size_t invokingSt
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::FuncCallContext* TocParser::ExprContext::funcCall() {\r
-  return getRuleContext<TocParser::FuncCallContext>(0);\r
-}\r
-\r
-TocParser::LiteralContext* TocParser::ExprContext::literal() {\r
-  return getRuleContext<TocParser::LiteralContext>(0);\r
-}\r
-\r
-TocParser::IdentifierContext* TocParser::ExprContext::identifier() {\r
-  return getRuleContext<TocParser::IdentifierContext>(0);\r
+TocParser::FuncExprContext* TocParser::ExprContext::funcExpr() {\r
+  return getRuleContext<TocParser::FuncExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::SubscriptContext* TocParser::ExprContext::subscript() {\r
-  return getRuleContext<TocParser::SubscriptContext>(0);\r
+TocParser::LitExprContext* TocParser::ExprContext::litExpr() {\r
+  return getRuleContext<TocParser::LitExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::MemberAccessContext* TocParser::ExprContext::memberAccess() {\r
-  return getRuleContext<TocParser::MemberAccessContext>(0);\r
+TocParser::IdentifierExprContext* TocParser::ExprContext::identifierExpr() {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(0);\r

 }\r
 \r
 TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {\r
   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r
 }\r
 \r
 TocParser::ParenExprContext* TocParser::ExprContext::parenExpr() {\r
   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r

-TocParser::OperatorExprContext* TocParser::ExprContext::operatorExpr() {\r
-  return getRuleContext<TocParser::OperatorExprContext>(0);\r
+TocParser::AccessExprContext* TocParser::ExprContext::accessExpr() {\r
+  return getRuleContext<TocParser::AccessExprContext>(0);\r
+}\r
+\r
+TocParser::OpExprContext* TocParser::ExprContext::opExpr() {\r
+  return getRuleContext<TocParser::OpExprContext>(0);\r

 }\r
 \r
 \r
 }\r
 \r
 \r


@@ -1430,7 +1804,7 @@ void TocParser::ExprContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::ExprContext* TocParser::expr() {\r
   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());\r
 \r
 TocParser::ExprContext* TocParser::expr() {\r
   ExprContext *_localctx = _tracker.createInstance<ExprContext>(_ctx, getState());\r

-  enterRule(_localctx, 40, TocParser::RuleExpr);\r
+  enterRule(_localctx, 46, TocParser::RuleExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1440,55 +1814,48 @@ TocParser::ExprContext* TocParser::expr() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    setState(181);\r
+    setState(246);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
       enterOuterAlt(_localctx, 1);\r
     case 1: {\r
       enterOuterAlt(_localctx, 1);\r

-      setState(174);\r
-      funcCall();\r
+      setState(240);\r
+      funcExpr();\r

       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r

-      setState(175);\r
-      literal();\r
+      setState(241);\r
+      litExpr();\r

       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r
       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r

-      setState(176);\r
-      identifier();\r
+      setState(242);\r
+      identifierExpr();\r

       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r
       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r

-      setState(177);\r
-      subscript();\r
+      setState(243);\r
+      parenExpr();\r

       break;\r
     }\r
 \r
     case 5: {\r
       enterOuterAlt(_localctx, 5);\r
       break;\r
     }\r
 \r
     case 5: {\r
       enterOuterAlt(_localctx, 5);\r

-      setState(178);\r
-      memberAccess();\r
+      setState(244);\r
+      accessExpr();\r

       break;\r
     }\r
 \r
     case 6: {\r
       enterOuterAlt(_localctx, 6);\r
       break;\r
     }\r
 \r
     case 6: {\r
       enterOuterAlt(_localctx, 6);\r

-      setState(179);\r
-      parenExpr();\r
-      break;\r
-    }\r
-\r
-    case 7: {\r
-      enterOuterAlt(_localctx, 7);\r
-      setState(180);\r
-      operatorExpr();\r
+      setState(245);\r
+      opExpr();\r

       break;\r
     }\r
 \r
       break;\r
     }\r
 \r


@@ -1512,30 +1879,26 @@ TocParser::NonOpExprContext::NonOpExprContext(ParserRuleContext *parent, size_t
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::FuncCallContext* TocParser::NonOpExprContext::funcCall() {\r
-  return getRuleContext<TocParser::FuncCallContext>(0);\r
-}\r
-\r
-TocParser::LiteralContext* TocParser::NonOpExprContext::literal() {\r
-  return getRuleContext<TocParser::LiteralContext>(0);\r
-}\r
-\r
-TocParser::IdentifierContext* TocParser::NonOpExprContext::identifier() {\r
-  return getRuleContext<TocParser::IdentifierContext>(0);\r
+TocParser::FuncExprContext* TocParser::NonOpExprContext::funcExpr() {\r
+  return getRuleContext<TocParser::FuncExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::SubscriptContext* TocParser::NonOpExprContext::subscript() {\r
-  return getRuleContext<TocParser::SubscriptContext>(0);\r
+TocParser::LitExprContext* TocParser::NonOpExprContext::litExpr() {\r
+  return getRuleContext<TocParser::LitExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::MemberAccessContext* TocParser::NonOpExprContext::memberAccess() {\r
-  return getRuleContext<TocParser::MemberAccessContext>(0);\r
+TocParser::IdentifierExprContext* TocParser::NonOpExprContext::identifierExpr() {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(0);\r

 }\r
 \r
 TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {\r
   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r
 }\r
 \r
 TocParser::ParenExprContext* TocParser::NonOpExprContext::parenExpr() {\r
   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r

+TocParser::AccessExprContext* TocParser::NonOpExprContext::accessExpr() {\r
+  return getRuleContext<TocParser::AccessExprContext>(0);\r
+}\r
+\r

 \r
 size_t TocParser::NonOpExprContext::getRuleIndex() const {\r
   return TocParser::RuleNonOpExpr;\r
 \r
 size_t TocParser::NonOpExprContext::getRuleIndex() const {\r
   return TocParser::RuleNonOpExpr;\r


@@ -1555,7 +1918,7 @@ void TocParser::NonOpExprContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::NonOpExprContext* TocParser::nonOpExpr() {\r
   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());\r
 \r
 TocParser::NonOpExprContext* TocParser::nonOpExpr() {\r
   NonOpExprContext *_localctx = _tracker.createInstance<NonOpExprContext>(_ctx, getState());\r

-  enterRule(_localctx, 42, TocParser::RuleNonOpExpr);\r
+  enterRule(_localctx, 48, TocParser::RuleNonOpExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1565,48 +1928,41 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    setState(189);\r
+    setState(253);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
       enterOuterAlt(_localctx, 1);\r
     case 1: {\r
       enterOuterAlt(_localctx, 1);\r

-      setState(183);\r
-      funcCall();\r
+      setState(248);\r
+      funcExpr();\r

       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r

-      setState(184);\r
-      literal();\r
+      setState(249);\r
+      litExpr();\r

       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r
       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r

-      setState(185);\r
-      identifier();\r
+      setState(250);\r
+      identifierExpr();\r

       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r
       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r

-      setState(186);\r
-      subscript();\r
+      setState(251);\r
+      parenExpr();\r

       break;\r
     }\r
 \r
     case 5: {\r
       enterOuterAlt(_localctx, 5);\r
       break;\r
     }\r
 \r
     case 5: {\r
       enterOuterAlt(_localctx, 5);\r

-      setState(187);\r
-      memberAccess();\r
-      break;\r
-    }\r
-\r
-    case 6: {\r
-      enterOuterAlt(_localctx, 6);\r
-      setState(188);\r
-      parenExpr();\r
+      setState(252);\r
+      accessExpr();\r

       break;\r
     }\r
 \r
       break;\r
     }\r
 \r


@@ -1624,52 +1980,44 @@ TocParser::NonOpExprContext* TocParser::nonOpExpr() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- NonSubscriptExprContext ------------------------------------------------------------------\r
+//----------------- NonAccessExprContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::NonSubscriptExprContext::NonSubscriptExprContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::FuncCallContext* TocParser::NonSubscriptExprContext::funcCall() {\r
-  return getRuleContext<TocParser::FuncCallContext>(0);\r
-}\r
-\r
-TocParser::LiteralContext* TocParser::NonSubscriptExprContext::literal() {\r
-  return getRuleContext<TocParser::LiteralContext>(0);\r
+TocParser::FuncExprContext* TocParser::NonAccessExprContext::funcExpr() {\r
+  return getRuleContext<TocParser::FuncExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::IdentifierContext* TocParser::NonSubscriptExprContext::identifier() {\r
-  return getRuleContext<TocParser::IdentifierContext>(0);\r
+TocParser::IdentifierExprContext* TocParser::NonAccessExprContext::identifierExpr() {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::MemberAccessContext* TocParser::NonSubscriptExprContext::memberAccess() {\r
-  return getRuleContext<TocParser::MemberAccessContext>(0);\r
-}\r
-\r
-TocParser::ParenExprContext* TocParser::NonSubscriptExprContext::parenExpr() {\r
+TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() {\r

   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r
 \r
   return getRuleContext<TocParser::ParenExprContext>(0);\r
 }\r
 \r
 \r

-size_t TocParser::NonSubscriptExprContext::getRuleIndex() const {\r
-  return TocParser::RuleNonSubscriptExpr;\r
+size_t TocParser::NonAccessExprContext::getRuleIndex() const {\r
+  return TocParser::RuleNonAccessExpr;\r

 }\r
 \r
 }\r
 \r

-void TocParser::NonSubscriptExprContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterNonSubscriptExpr(this);\r
+    parserListener->enterNonAccessExpr(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::NonSubscriptExprContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitNonSubscriptExpr(this);\r
+    parserListener->exitNonAccessExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {\r
-  NonSubscriptExprContext *_localctx = _tracker.createInstance<NonSubscriptExprContext>(_ctx, getState());\r
-  enterRule(_localctx, 44, TocParser::RuleNonSubscriptExpr);\r
+TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {\r
+  NonAccessExprContext *_localctx = _tracker.createInstance<NonAccessExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 50, TocParser::RuleNonAccessExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1679,40 +2027,26 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    setState(196);\r
+    setState(258);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
       enterOuterAlt(_localctx, 1);\r
     case 1: {\r
       enterOuterAlt(_localctx, 1);\r

-      setState(191);\r
-      funcCall();\r
+      setState(255);\r
+      funcExpr();\r

       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r

-      setState(192);\r
-      literal();\r
+      setState(256);\r
+      identifierExpr();\r

       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r
       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r

-      setState(193);\r
-      identifier();\r
-      break;\r
-    }\r
-\r
-    case 4: {\r
-      enterOuterAlt(_localctx, 4);\r
-      setState(194);\r
-      memberAccess();\r
-      break;\r
-    }\r
-\r
-    case 5: {\r
-      enterOuterAlt(_localctx, 5);\r
-      setState(195);\r
+      setState(257);\r

       parenExpr();\r
       break;\r
     }\r
       parenExpr();\r
       break;\r
     }\r


@@ -1731,56 +2065,141 @@ TocParser::NonSubscriptExprContext* TocParser::nonSubscriptExpr() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- NonAccessExprContext ------------------------------------------------------------------\r
+//----------------- FuncExprContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::NonAccessExprContext::NonAccessExprContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::FuncExprContext::FuncExprContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::FuncCallContext* TocParser::NonAccessExprContext::funcCall() {\r
-  return getRuleContext<TocParser::FuncCallContext>(0);\r
+TocParser::FuncNameContext* TocParser::FuncExprContext::funcName() {\r
+  return getRuleContext<TocParser::FuncNameContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::LiteralContext* TocParser::NonAccessExprContext::literal() {\r
-  return getRuleContext<TocParser::LiteralContext>(0);\r
+std::vector<TocParser::ExprContext *> TocParser::FuncExprContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r

 }\r
 \r
 }\r
 \r

-TocParser::IdentifierContext* TocParser::NonAccessExprContext::identifier() {\r
-  return getRuleContext<TocParser::IdentifierContext>(0);\r
+TocParser::ExprContext* TocParser::FuncExprContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r

 }\r
 \r
 }\r
 \r

-TocParser::SubscriptContext* TocParser::NonAccessExprContext::subscript() {\r
-  return getRuleContext<TocParser::SubscriptContext>(0);\r
+\r
+size_t TocParser::FuncExprContext::getRuleIndex() const {\r
+  return TocParser::RuleFuncExpr;\r

 }\r
 \r
 }\r
 \r

-TocParser::ParenExprContext* TocParser::NonAccessExprContext::parenExpr() {\r
-  return getRuleContext<TocParser::ParenExprContext>(0);\r
+void TocParser::FuncExprContext::enterRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->enterFuncExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::OperatorExprContext* TocParser::NonAccessExprContext::operatorExpr() {\r
-  return getRuleContext<TocParser::OperatorExprContext>(0);\r
+void TocParser::FuncExprContext::exitRule(tree::ParseTreeListener *listener) {\r
+  auto parserListener = dynamic_cast<TocListener *>(listener);\r
+  if (parserListener != nullptr)\r
+    parserListener->exitFuncExpr(this);\r

 }\r
 \r
 }\r
 \r

+TocParser::FuncExprContext* TocParser::funcExpr() {\r
+  FuncExprContext *_localctx = _tracker.createInstance<FuncExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 52, TocParser::RuleFuncExpr);\r
+  size_t _la = 0;\r

 \r
 \r

-size_t TocParser::NonAccessExprContext::getRuleIndex() const {\r
-  return TocParser::RuleNonAccessExpr;\r
+#if __cplusplus > 201703L\r
+  auto onExit = finally([=, this] {\r
+#else\r
+  auto onExit = finally([=] {\r
+#endif\r
+    exitRule();\r
+  });\r
+  try {\r
+    enterOuterAlt(_localctx, 1);\r
+    setState(260);\r
+    funcName();\r
+    setState(261);\r
+    match(TocParser::T__7);\r
+    setState(270);\r
+    _errHandler->sync(this);\r
+\r
+    _la = _input->LA(1);\r
+    if ((((_la & ~ 0x3fULL) == 0) &&\r
+      ((1ULL << _la) & ((1ULL << TocParser::T__7)\r
+      | (1ULL << TocParser::PREFIX_OP)\r
+      | (1ULL << TocParser::INT_LIT)\r
+      | (1ULL << TocParser::DECIMAL_LIT)\r
+      | (1ULL << TocParser::STRING_LIT)\r
+      | (1ULL << TocParser::BOOL_LIT)\r
+      | (1ULL << TocParser::NAME))) != 0)) {\r
+      setState(262);\r
+      expr();\r
+      setState(267);\r
+      _errHandler->sync(this);\r
+      _la = _input->LA(1);\r
+      while (_la == TocParser::T__9) {\r
+        setState(263);\r
+        match(TocParser::T__9);\r
+        setState(264);\r
+        expr();\r
+        setState(269);\r
+        _errHandler->sync(this);\r
+        _la = _input->LA(1);\r
+      }\r
+    }\r
+    setState(272);\r
+    match(TocParser::T__8);\r
+   \r
+  }\r
+  catch (RecognitionException &e) {\r
+    _errHandler->reportError(this, e);\r
+    _localctx->exception = std::current_exception();\r
+    _errHandler->recover(this, _localctx->exception);\r
+  }\r
+\r
+  return _localctx;\r

 }\r
 \r
 }\r
 \r

-void TocParser::NonAccessExprContext::enterRule(tree::ParseTreeListener *listener) {\r
+//----------------- OpExprContext ------------------------------------------------------------------\r
+\r
+TocParser::OpExprContext::OpExprContext(ParserRuleContext *parent, size_t invokingState)\r
+  : ParserRuleContext(parent, invokingState) {\r
+}\r
+\r
+TocParser::BinaryOpContext* TocParser::OpExprContext::binaryOp() {\r
+  return getRuleContext<TocParser::BinaryOpContext>(0);\r
+}\r
+\r
+TocParser::PrefixOpContext* TocParser::OpExprContext::prefixOp() {\r
+  return getRuleContext<TocParser::PrefixOpContext>(0);\r
+}\r
+\r
+TocParser::PostfixOpContext* TocParser::OpExprContext::postfixOp() {\r
+  return getRuleContext<TocParser::PostfixOpContext>(0);\r
+}\r
+\r
+TocParser::TernaryOpContext* TocParser::OpExprContext::ternaryOp() {\r
+  return getRuleContext<TocParser::TernaryOpContext>(0);\r
+}\r
+\r
+\r
+size_t TocParser::OpExprContext::getRuleIndex() const {\r
+  return TocParser::RuleOpExpr;\r
+}\r
+\r
+void TocParser::OpExprContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterNonAccessExpr(this);\r
+    parserListener->enterOpExpr(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::NonAccessExprContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::OpExprContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitNonAccessExpr(this);\r
+    parserListener->exitOpExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {\r
-  NonAccessExprContext *_localctx = _tracker.createInstance<NonAccessExprContext>(_ctx, getState());\r
-  enterRule(_localctx, 46, TocParser::RuleNonAccessExpr);\r
+TocParser::OpExprContext* TocParser::opExpr() {\r
+  OpExprContext *_localctx = _tracker.createInstance<OpExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 54, TocParser::RuleOpExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1790,48 +2209,34 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {
     exitRule();\r
   });\r
   try {\r
     exitRule();\r
   });\r
   try {\r

-    setState(204);\r
+    setState(278);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

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

     case 1: {\r
       enterOuterAlt(_localctx, 1);\r
     case 1: {\r
       enterOuterAlt(_localctx, 1);\r

-      setState(198);\r
-      funcCall();\r
+      setState(274);\r
+      binaryOp();\r

       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r
       break;\r
     }\r
 \r
     case 2: {\r
       enterOuterAlt(_localctx, 2);\r

-      setState(199);\r
-      literal();\r
+      setState(275);\r
+      prefixOp();\r

       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r
       break;\r
     }\r
 \r
     case 3: {\r
       enterOuterAlt(_localctx, 3);\r

-      setState(200);\r
-      identifier();\r
+      setState(276);\r
+      postfixOp();\r

       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r
       break;\r
     }\r
 \r
     case 4: {\r
       enterOuterAlt(_localctx, 4);\r

-      setState(201);\r
-      subscript();\r
-      break;\r
-    }\r
-\r
-    case 5: {\r
-      enterOuterAlt(_localctx, 5);\r
-      setState(202);\r
-      parenExpr();\r
-      break;\r
-    }\r
-\r
-    case 6: {\r
-      enterOuterAlt(_localctx, 6);\r
-      setState(203);\r
-      operatorExpr();\r
+      setState(277);\r
+      ternaryOp();\r

       break;\r
     }\r
 \r
       break;\r
     }\r
 \r


@@ -1849,44 +2254,48 @@ TocParser::NonAccessExprContext* TocParser::nonAccessExpr() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- FuncCallContext ------------------------------------------------------------------\r
+//----------------- BinaryOpContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::FuncCallContext::FuncCallContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::BinaryOpContext::BinaryOpContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::FuncNameContext* TocParser::FuncCallContext::funcName() {\r
-  return getRuleContext<TocParser::FuncNameContext>(0);\r
+std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOpContext::nonOpExpr() {\r
+  return getRuleContexts<TocParser::NonOpExprContext>();\r

 }\r
 \r
 }\r
 \r

-std::vector<TocParser::ExprContext *> TocParser::FuncCallContext::expr() {\r
-  return getRuleContexts<TocParser::ExprContext>();\r
+TocParser::NonOpExprContext* TocParser::BinaryOpContext::nonOpExpr(size_t i) {\r
+  return getRuleContext<TocParser::NonOpExprContext>(i);\r

 }\r
 \r
 }\r
 \r

-TocParser::ExprContext* TocParser::FuncCallContext::expr(size_t i) {\r
-  return getRuleContext<TocParser::ExprContext>(i);\r
+std::vector<tree::TerminalNode *> TocParser::BinaryOpContext::BINARY_OP() {\r
+  return getTokens(TocParser::BINARY_OP);\r

 }\r
 \r
 }\r
 \r

+tree::TerminalNode* TocParser::BinaryOpContext::BINARY_OP(size_t i) {\r
+  return getToken(TocParser::BINARY_OP, i);\r
+}\r

 \r
 \r

-size_t TocParser::FuncCallContext::getRuleIndex() const {\r
-  return TocParser::RuleFuncCall;\r
+\r
+size_t TocParser::BinaryOpContext::getRuleIndex() const {\r
+  return TocParser::RuleBinaryOp;\r

 }\r
 \r
 }\r
 \r

-void TocParser::FuncCallContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::BinaryOpContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterFuncCall(this);\r
+    parserListener->enterBinaryOp(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::FuncCallContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::BinaryOpContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitFuncCall(this);\r
+    parserListener->exitBinaryOp(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::FuncCallContext* TocParser::funcCall() {\r
-  FuncCallContext *_localctx = _tracker.createInstance<FuncCallContext>(_ctx, getState());\r
-  enterRule(_localctx, 48, TocParser::RuleFuncCall);\r
+TocParser::BinaryOpContext* TocParser::binaryOp() {\r
+  BinaryOpContext *_localctx = _tracker.createInstance<BinaryOpContext>(_ctx, getState());\r
+  enterRule(_localctx, 56, TocParser::RuleBinaryOp);\r

   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r
   size_t _la = 0;\r
 \r
 #if __cplusplus > 201703L\r


@@ -1898,35 +2307,24 @@ TocParser::FuncCallContext* TocParser::funcCall() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(206);\r
-    funcName();\r
-    setState(207);\r
-    match(TocParser::T__4);\r
-    setState(216);\r
+    setState(280);\r
+    nonOpExpr();\r
+    setState(281);\r
+    match(TocParser::BINARY_OP);\r
+    setState(282);\r
+    nonOpExpr();\r
+    setState(287);\r

     _errHandler->sync(this);\r
     _errHandler->sync(this);\r

-\r

     _la = _input->LA(1);\r
     _la = _input->LA(1);\r

-    if ((((_la & ~ 0x3fULL) == 0) &&\r
-      ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
-      | (1ULL << TocParser::INTLIT)\r
-      | (1ULL << TocParser::NAME))) != 0)) {\r
-      setState(208);\r
-      expr();\r
-      setState(213);\r
+    while (_la == TocParser::BINARY_OP) {\r
+      setState(283);\r
+      match(TocParser::BINARY_OP);\r
+      setState(284);\r
+      nonOpExpr();\r
+      setState(289);\r

       _errHandler->sync(this);\r
       _la = _input->LA(1);\r
       _errHandler->sync(this);\r
       _la = _input->LA(1);\r

-      while (_la == TocParser::T__6) {\r
-        setState(209);\r
-        match(TocParser::T__6);\r
-        setState(210);\r
-        expr();\r
-        setState(215);\r
-        _errHandler->sync(this);\r
-        _la = _input->LA(1);\r
-      }\r

     }\r
     }\r

-    setState(218);\r
-    match(TocParser::T__5);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -1938,36 +2336,40 @@ TocParser::FuncCallContext* TocParser::funcCall() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- OperatorExprContext ------------------------------------------------------------------\r
+//----------------- PrefixOpContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::OperatorExprContext::OperatorExprContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::PrefixOpContext::PrefixOpContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::BinaryOperatorContext* TocParser::OperatorExprContext::binaryOperator() {\r
-  return getRuleContext<TocParser::BinaryOperatorContext>(0);\r
+tree::TerminalNode* TocParser::PrefixOpContext::PREFIX_OP() {\r
+  return getToken(TocParser::PREFIX_OP, 0);\r

 }\r
 \r
 }\r
 \r

+TocParser::NonOpExprContext* TocParser::PrefixOpContext::nonOpExpr() {\r
+  return getRuleContext<TocParser::NonOpExprContext>(0);\r
+}\r

 \r
 \r

-size_t TocParser::OperatorExprContext::getRuleIndex() const {\r
-  return TocParser::RuleOperatorExpr;\r
+\r
+size_t TocParser::PrefixOpContext::getRuleIndex() const {\r
+  return TocParser::RulePrefixOp;\r

 }\r
 \r
 }\r
 \r

-void TocParser::OperatorExprContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::PrefixOpContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterOperatorExpr(this);\r
+    parserListener->enterPrefixOp(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::OperatorExprContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::PrefixOpContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitOperatorExpr(this);\r
+    parserListener->exitPrefixOp(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::OperatorExprContext* TocParser::operatorExpr() {\r
-  OperatorExprContext *_localctx = _tracker.createInstance<OperatorExprContext>(_ctx, getState());\r
-  enterRule(_localctx, 50, TocParser::RuleOperatorExpr);\r
+TocParser::PrefixOpContext* TocParser::prefixOp() {\r
+  PrefixOpContext *_localctx = _tracker.createInstance<PrefixOpContext>(_ctx, getState());\r
+  enterRule(_localctx, 58, TocParser::RulePrefixOp);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -1978,8 +2380,10 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(220);\r
-    binaryOperator();\r
+    setState(290);\r
+    match(TocParser::PREFIX_OP);\r
+    setState(291);\r
+    nonOpExpr();\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -1991,49 +2395,40 @@ TocParser::OperatorExprContext* TocParser::operatorExpr() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- BinaryOperatorContext ------------------------------------------------------------------\r
+//----------------- PostfixOpContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::BinaryOperatorContext::BinaryOperatorContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::PostfixOpContext::PostfixOpContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-std::vector<TocParser::NonOpExprContext *> TocParser::BinaryOperatorContext::nonOpExpr() {\r
-  return getRuleContexts<TocParser::NonOpExprContext>();\r
-}\r
-\r
-TocParser::NonOpExprContext* TocParser::BinaryOperatorContext::nonOpExpr(size_t i) {\r
-  return getRuleContext<TocParser::NonOpExprContext>(i);\r
-}\r
-\r
-std::vector<tree::TerminalNode *> TocParser::BinaryOperatorContext::BINARY_OPERATOR() {\r
-  return getTokens(TocParser::BINARY_OPERATOR);\r
+TocParser::NonOpExprContext* TocParser::PostfixOpContext::nonOpExpr() {\r
+  return getRuleContext<TocParser::NonOpExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-tree::TerminalNode* TocParser::BinaryOperatorContext::BINARY_OPERATOR(size_t i) {\r
-  return getToken(TocParser::BINARY_OPERATOR, i);\r
+tree::TerminalNode* TocParser::PostfixOpContext::POSTFIX_OP() {\r
+  return getToken(TocParser::POSTFIX_OP, 0);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::BinaryOperatorContext::getRuleIndex() const {\r
-  return TocParser::RuleBinaryOperator;\r
+size_t TocParser::PostfixOpContext::getRuleIndex() const {\r
+  return TocParser::RulePostfixOp;\r

 }\r
 \r
 }\r
 \r

-void TocParser::BinaryOperatorContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::PostfixOpContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterBinaryOperator(this);\r
+    parserListener->enterPostfixOp(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::BinaryOperatorContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::PostfixOpContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitBinaryOperator(this);\r
+    parserListener->exitPostfixOp(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::BinaryOperatorContext* TocParser::binaryOperator() {\r
-  BinaryOperatorContext *_localctx = _tracker.createInstance<BinaryOperatorContext>(_ctx, getState());\r
-  enterRule(_localctx, 52, TocParser::RuleBinaryOperator);\r
-  size_t _la = 0;\r
+TocParser::PostfixOpContext* TocParser::postfixOp() {\r
+  PostfixOpContext *_localctx = _tracker.createInstance<PostfixOpContext>(_ctx, getState());\r
+  enterRule(_localctx, 60, TocParser::RulePostfixOp);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2044,24 +2439,10 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(222);\r
-    nonOpExpr();\r
-    setState(223);\r
-    match(TocParser::BINARY_OPERATOR);\r
-    setState(224);\r
+    setState(293);\r

     nonOpExpr();\r
     nonOpExpr();\r

-    setState(229);\r
-    _errHandler->sync(this);\r
-    _la = _input->LA(1);\r
-    while (_la == TocParser::BINARY_OPERATOR) {\r
-      setState(225);\r
-      match(TocParser::BINARY_OPERATOR);\r
-      setState(226);\r
-      nonOpExpr();\r
-      setState(231);\r
-      _errHandler->sync(this);\r
-      _la = _input->LA(1);\r
-    }\r
+    setState(294);\r
+    match(TocParser::POSTFIX_OP);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2073,36 +2454,44 @@ TocParser::BinaryOperatorContext* TocParser::binaryOperator() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- IdentifierContext ------------------------------------------------------------------\r
+//----------------- TernaryOpContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::IdentifierContext::IdentifierContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::TernaryOpContext::TernaryOpContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::VarNameContext* TocParser::IdentifierContext::varName() {\r
-  return getRuleContext<TocParser::VarNameContext>(0);\r
+TocParser::NonOpExprContext* TocParser::TernaryOpContext::nonOpExpr() {\r
+  return getRuleContext<TocParser::NonOpExprContext>(0);\r

 }\r
 \r
 }\r
 \r

+std::vector<TocParser::ExprContext *> TocParser::TernaryOpContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r
+}\r

 \r
 \r

-size_t TocParser::IdentifierContext::getRuleIndex() const {\r
-  return TocParser::RuleIdentifier;\r
+TocParser::ExprContext* TocParser::TernaryOpContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r

 }\r
 \r
 }\r
 \r

-void TocParser::IdentifierContext::enterRule(tree::ParseTreeListener *listener) {\r
+\r
+size_t TocParser::TernaryOpContext::getRuleIndex() const {\r
+  return TocParser::RuleTernaryOp;\r
+}\r
+\r
+void TocParser::TernaryOpContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterIdentifier(this);\r
+    parserListener->enterTernaryOp(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::IdentifierContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::TernaryOpContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitIdentifier(this);\r
+    parserListener->exitTernaryOp(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::IdentifierContext* TocParser::identifier() {\r
-  IdentifierContext *_localctx = _tracker.createInstance<IdentifierContext>(_ctx, getState());\r
-  enterRule(_localctx, 54, TocParser::RuleIdentifier);\r
+TocParser::TernaryOpContext* TocParser::ternaryOp() {\r
+  TernaryOpContext *_localctx = _tracker.createInstance<TernaryOpContext>(_ctx, getState());\r
+  enterRule(_localctx, 62, TocParser::RuleTernaryOp);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2113,8 +2502,16 @@ TocParser::IdentifierContext* TocParser::identifier() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(232);\r
-    varName();\r
+    setState(296);\r
+    nonOpExpr();\r
+    setState(297);\r
+    match(TocParser::T__20);\r
+    setState(298);\r
+    expr();\r
+    setState(299);\r
+    match(TocParser::T__1);\r
+    setState(300);\r
+    expr();\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2126,36 +2523,36 @@ TocParser::IdentifierContext* TocParser::identifier() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- LiteralContext ------------------------------------------------------------------\r
+//----------------- IdentifierExprContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::LiteralContext::LiteralContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::IdentifierExprContext::IdentifierExprContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-tree::TerminalNode* TocParser::LiteralContext::INTLIT() {\r
-  return getToken(TocParser::INTLIT, 0);\r
+TocParser::VarNameContext* TocParser::IdentifierExprContext::varName() {\r
+  return getRuleContext<TocParser::VarNameContext>(0);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::LiteralContext::getRuleIndex() const {\r
-  return TocParser::RuleLiteral;\r
+size_t TocParser::IdentifierExprContext::getRuleIndex() const {\r
+  return TocParser::RuleIdentifierExpr;\r

 }\r
 \r
 }\r
 \r

-void TocParser::LiteralContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::IdentifierExprContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterLiteral(this);\r
+    parserListener->enterIdentifierExpr(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::LiteralContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::IdentifierExprContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitLiteral(this);\r
+    parserListener->exitIdentifierExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::LiteralContext* TocParser::literal() {\r
-  LiteralContext *_localctx = _tracker.createInstance<LiteralContext>(_ctx, getState());\r
-  enterRule(_localctx, 56, TocParser::RuleLiteral);\r
+TocParser::IdentifierExprContext* TocParser::identifierExpr() {\r
+  IdentifierExprContext *_localctx = _tracker.createInstance<IdentifierExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 64, TocParser::RuleIdentifierExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2166,8 +2563,8 @@ TocParser::LiteralContext* TocParser::literal() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(234);\r
-    match(TocParser::INTLIT);\r
+    setState(302);\r
+    varName();\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2179,40 +2576,49 @@ TocParser::LiteralContext* TocParser::literal() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- SubscriptContext ------------------------------------------------------------------\r
+//----------------- LitExprContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::SubscriptContext::SubscriptContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::LitExprContext::LitExprContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-TocParser::NonSubscriptExprContext* TocParser::SubscriptContext::nonSubscriptExpr() {\r
-  return getRuleContext<TocParser::NonSubscriptExprContext>(0);\r
+tree::TerminalNode* TocParser::LitExprContext::INT_LIT() {\r
+  return getToken(TocParser::INT_LIT, 0);\r

 }\r
 \r
 }\r
 \r

-TocParser::ExprContext* TocParser::SubscriptContext::expr() {\r
-  return getRuleContext<TocParser::ExprContext>(0);\r
+tree::TerminalNode* TocParser::LitExprContext::DECIMAL_LIT() {\r
+  return getToken(TocParser::DECIMAL_LIT, 0);\r
+}\r
+\r
+tree::TerminalNode* TocParser::LitExprContext::STRING_LIT() {\r
+  return getToken(TocParser::STRING_LIT, 0);\r
+}\r
+\r
+tree::TerminalNode* TocParser::LitExprContext::BOOL_LIT() {\r
+  return getToken(TocParser::BOOL_LIT, 0);\r

 }\r
 \r
 \r
 }\r
 \r
 \r

-size_t TocParser::SubscriptContext::getRuleIndex() const {\r
-  return TocParser::RuleSubscript;\r
+size_t TocParser::LitExprContext::getRuleIndex() const {\r
+  return TocParser::RuleLitExpr;\r

 }\r
 \r
 }\r
 \r

-void TocParser::SubscriptContext::enterRule(tree::ParseTreeListener *listener) {\r
+void TocParser::LitExprContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterSubscript(this);\r
+    parserListener->enterLitExpr(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::SubscriptContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::LitExprContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitSubscript(this);\r
+    parserListener->exitLitExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::SubscriptContext* TocParser::subscript() {\r
-  SubscriptContext *_localctx = _tracker.createInstance<SubscriptContext>(_ctx, getState());\r
-  enterRule(_localctx, 58, TocParser::RuleSubscript);\r
+TocParser::LitExprContext* TocParser::litExpr() {\r
+  LitExprContext *_localctx = _tracker.createInstance<LitExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 66, TocParser::RuleLitExpr);\r
+  size_t _la = 0;\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2223,14 +2629,19 @@ TocParser::SubscriptContext* TocParser::subscript() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(236);\r
-    nonSubscriptExpr();\r
-    setState(237);\r
-    match(TocParser::T__13);\r
-    setState(238);\r
-    expr();\r
-    setState(239);\r
-    match(TocParser::T__14);\r
+    setState(304);\r
+    _la = _input->LA(1);\r
+    if (!((((_la & ~ 0x3fULL) == 0) &&\r
+      ((1ULL << _la) & ((1ULL << TocParser::INT_LIT)\r
+      | (1ULL << TocParser::DECIMAL_LIT)\r
+      | (1ULL << TocParser::STRING_LIT)\r
+      | (1ULL << TocParser::BOOL_LIT))) != 0))) {\r
+    _errHandler->recoverInline(this);\r
+    }\r
+    else {\r
+      _errHandler->reportMatch(this);\r
+      consume();\r
+    }\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2242,40 +2653,53 @@ TocParser::SubscriptContext* TocParser::subscript() {
   return _localctx;\r
 }\r
 \r
   return _localctx;\r
 }\r
 \r

-//----------------- MemberAccessContext ------------------------------------------------------------------\r
+//----------------- AccessExprContext ------------------------------------------------------------------\r

 \r
 \r

-TocParser::MemberAccessContext::MemberAccessContext(ParserRuleContext *parent, size_t invokingState)\r
+TocParser::AccessExprContext::AccessExprContext(ParserRuleContext *parent, size_t invokingState)\r

   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r
   : ParserRuleContext(parent, invokingState) {\r
 }\r
 \r

-std::vector<TocParser::IdentifierContext *> TocParser::MemberAccessContext::identifier() {\r
-  return getRuleContexts<TocParser::IdentifierContext>();\r
+TocParser::NonAccessExprContext* TocParser::AccessExprContext::nonAccessExpr() {\r
+  return getRuleContext<TocParser::NonAccessExprContext>(0);\r

 }\r
 \r
 }\r
 \r

-TocParser::IdentifierContext* TocParser::MemberAccessContext::identifier(size_t i) {\r
-  return getRuleContext<TocParser::IdentifierContext>(i);\r
+std::vector<TocParser::IdentifierExprContext *> TocParser::AccessExprContext::identifierExpr() {\r
+  return getRuleContexts<TocParser::IdentifierExprContext>();\r

 }\r
 \r
 }\r
 \r

+TocParser::IdentifierExprContext* TocParser::AccessExprContext::identifierExpr(size_t i) {\r
+  return getRuleContext<TocParser::IdentifierExprContext>(i);\r
+}\r

 \r
 \r

-size_t TocParser::MemberAccessContext::getRuleIndex() const {\r
-  return TocParser::RuleMemberAccess;\r
+std::vector<TocParser::ExprContext *> TocParser::AccessExprContext::expr() {\r
+  return getRuleContexts<TocParser::ExprContext>();\r

 }\r
 \r
 }\r
 \r

-void TocParser::MemberAccessContext::enterRule(tree::ParseTreeListener *listener) {\r
+TocParser::ExprContext* TocParser::AccessExprContext::expr(size_t i) {\r
+  return getRuleContext<TocParser::ExprContext>(i);\r
+}\r
+\r
+\r
+size_t TocParser::AccessExprContext::getRuleIndex() const {\r
+  return TocParser::RuleAccessExpr;\r
+}\r
+\r
+void TocParser::AccessExprContext::enterRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->enterMemberAccess(this);\r
+    parserListener->enterAccessExpr(this);\r

 }\r
 \r
 }\r
 \r

-void TocParser::MemberAccessContext::exitRule(tree::ParseTreeListener *listener) {\r
+void TocParser::AccessExprContext::exitRule(tree::ParseTreeListener *listener) {\r

   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r
   auto parserListener = dynamic_cast<TocListener *>(listener);\r
   if (parserListener != nullptr)\r

-    parserListener->exitMemberAccess(this);\r
+    parserListener->exitAccessExpr(this);\r

 }\r
 \r
 }\r
 \r

-TocParser::MemberAccessContext* TocParser::memberAccess() {\r
-  MemberAccessContext *_localctx = _tracker.createInstance<MemberAccessContext>(_ctx, getState());\r
-  enterRule(_localctx, 60, TocParser::RuleMemberAccess);\r
+TocParser::AccessExprContext* TocParser::accessExpr() {\r
+  AccessExprContext *_localctx = _tracker.createInstance<AccessExprContext>(_ctx, getState());\r
+  enterRule(_localctx, 68, TocParser::RuleAccessExpr);\r
+  size_t _la = 0;\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2286,12 +2710,53 @@ TocParser::MemberAccessContext* TocParser::memberAccess() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(241);\r
-    identifier();\r
-    setState(242);\r
-    match(TocParser::T__15);\r
-    setState(243);\r
-    identifier();\r
+    setState(306);\r
+    nonAccessExpr();\r
+    setState(313); \r
+    _errHandler->sync(this);\r
+    _la = _input->LA(1);\r
+    do {\r
+      setState(313);\r
+      _errHandler->sync(this);\r
+      switch (_input->LA(1)) {\r
+        case TocParser::T__21:\r
+        case TocParser::T__22: {\r
+          setState(307);\r
+          _la = _input->LA(1);\r
+          if (!(_la == TocParser::T__21\r
+\r
+          || _la == TocParser::T__22)) {\r
+          _errHandler->recoverInline(this);\r
+          }\r
+          else {\r
+            _errHandler->reportMatch(this);\r
+            consume();\r
+          }\r
+          setState(308);\r
+          identifierExpr();\r
+          break;\r
+        }\r
+\r
+        case TocParser::T__4: {\r
+          setState(309);\r
+          match(TocParser::T__4);\r
+          setState(310);\r
+          expr();\r
+          setState(311);\r
+          match(TocParser::T__5);\r
+          break;\r
+        }\r
+\r
+      default:\r
+        throw NoViableAltException(this);\r
+      }\r
+      setState(315); \r
+      _errHandler->sync(this);\r
+      _la = _input->LA(1);\r
+    } while ((((_la & ~ 0x3fULL) == 0) &&\r
+      ((1ULL << _la) & ((1ULL << TocParser::T__4)\r
+      | (1ULL << TocParser::T__21)\r
+      | (1ULL << TocParser::T__22))) != 0));\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2332,7 +2797,7 @@ void TocParser::ParenExprContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::ParenExprContext* TocParser::parenExpr() {\r
   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());\r
 \r
 TocParser::ParenExprContext* TocParser::parenExpr() {\r
   ParenExprContext *_localctx = _tracker.createInstance<ParenExprContext>(_ctx, getState());\r

-  enterRule(_localctx, 62, TocParser::RuleParenExpr);\r
+  enterRule(_localctx, 70, TocParser::RuleParenExpr);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2343,12 +2808,12 @@ TocParser::ParenExprContext* TocParser::parenExpr() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(245);\r
-    match(TocParser::T__4);\r
-    setState(246);\r
+    setState(317);\r
+    match(TocParser::T__7);\r
+    setState(318);\r

     expr();\r
     expr();\r

-    setState(247);\r
-    match(TocParser::T__5);\r
+    setState(319);\r
+    match(TocParser::T__8);\r

    \r
   }\r
   catch (RecognitionException &e) {\r
    \r
   }\r
   catch (RecognitionException &e) {\r


@@ -2389,7 +2854,7 @@ void TocParser::FuncNameContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::FuncNameContext* TocParser::funcName() {\r
   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());\r
 \r
 TocParser::FuncNameContext* TocParser::funcName() {\r
   FuncNameContext *_localctx = _tracker.createInstance<FuncNameContext>(_ctx, getState());\r

-  enterRule(_localctx, 64, TocParser::RuleFuncName);\r
+  enterRule(_localctx, 72, TocParser::RuleFuncName);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2400,7 +2865,7 @@ TocParser::FuncNameContext* TocParser::funcName() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(249);\r
+    setState(321);\r

     match(TocParser::NAME);\r
    \r
   }\r
     match(TocParser::NAME);\r
    \r
   }\r


@@ -2442,7 +2907,7 @@ void TocParser::VarNameContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::VarNameContext* TocParser::varName() {\r
   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());\r
 \r
 TocParser::VarNameContext* TocParser::varName() {\r
   VarNameContext *_localctx = _tracker.createInstance<VarNameContext>(_ctx, getState());\r

-  enterRule(_localctx, 66, TocParser::RuleVarName);\r
+  enterRule(_localctx, 74, TocParser::RuleVarName);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2453,7 +2918,7 @@ TocParser::VarNameContext* TocParser::varName() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(251);\r
+    setState(323);\r

     match(TocParser::NAME);\r
    \r
   }\r
     match(TocParser::NAME);\r
    \r
   }\r


@@ -2495,7 +2960,7 @@ void TocParser::TypeNameContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::TypeNameContext* TocParser::typeName() {\r
   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());\r
 \r
 TocParser::TypeNameContext* TocParser::typeName() {\r
   TypeNameContext *_localctx = _tracker.createInstance<TypeNameContext>(_ctx, getState());\r

-  enterRule(_localctx, 68, TocParser::RuleTypeName);\r
+  enterRule(_localctx, 76, TocParser::RuleTypeName);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2506,7 +2971,7 @@ TocParser::TypeNameContext* TocParser::typeName() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(253);\r
+    setState(325);\r

     match(TocParser::NAME);\r
    \r
   }\r
     match(TocParser::NAME);\r
    \r
   }\r


@@ -2548,7 +3013,7 @@ void TocParser::StructNameContext::exitRule(tree::ParseTreeListener *listener) {
 \r
 TocParser::StructNameContext* TocParser::structName() {\r
   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());\r
 \r
 TocParser::StructNameContext* TocParser::structName() {\r
   StructNameContext *_localctx = _tracker.createInstance<StructNameContext>(_ctx, getState());\r

-  enterRule(_localctx, 70, TocParser::RuleStructName);\r
+  enterRule(_localctx, 78, TocParser::RuleStructName);\r

 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r
 \r
 #if __cplusplus > 201703L\r
   auto onExit = finally([=, this] {\r


@@ -2559,7 +3024,7 @@ TocParser::StructNameContext* TocParser::structName() {
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r
   });\r
   try {\r
     enterOuterAlt(_localctx, 1);\r

-    setState(255);\r
+    setState(327);\r

     match(TocParser::NAME);\r
    \r
   }\r
     match(TocParser::NAME);\r
    \r
   }\r


@@ -2581,22 +3046,25 @@ atn::ATN TocParser::_atn;
 std::vector<uint16_t> TocParser::_serializedATN;\r
 \r
 std::vector<std::string> TocParser::_ruleNames = {\r
 std::vector<uint16_t> TocParser::_serializedATN;\r
 \r
 std::vector<std::string> TocParser::_ruleNames = {\r

-  "prog", "decl", "varDecl", "var", "type", "funcDecl", "func", "parameter", \r
-  "body", "structDecl", "structMember", "structVar", "structMethod", "stmt", \r
-  "conditional", "ifCond", "loop", "whileLoop", "assignment", "returnStmt", \r
-  "expr", "nonOpExpr", "nonSubscriptExpr", "nonAccessExpr", "funcCall", \r
-  "operatorExpr", "binaryOperator", "identifier", "literal", "subscript", \r
-  "memberAccess", "parenExpr", "funcName", "varName", "typeName", "structName"\r
+  "prog", "decl", "varDecl", "var", "varInit", "type", "typeModifier", "funcDecl", \r
+  "func", "parameter", "body", "structDecl", "structMember", "structVar", \r
+  "structMethod", "stmt", "ifStmt", "switchStmt", "switchBody", "forStmt", \r
+  "whileStmt", "assignStmt", "returnStmt", "expr", "nonOpExpr", "nonAccessExpr", \r
+  "funcExpr", "opExpr", "binaryOp", "prefixOp", "postfixOp", "ternaryOp", \r
+  "identifierExpr", "litExpr", "accessExpr", "parenExpr", "funcName", "varName", \r
+  "typeName", "structName"\r

 };\r
 \r
 std::vector<std::string> TocParser::_literalNames = {\r
 };\r
 \r
 std::vector<std::string> TocParser::_literalNames = {\r

-  "", "'var'", "':'", "'='", "'func'", "'('", "')'", "','", "'{'", "'}'", \r
-  "'struct'", "'if'", "'while'", "'return'", "'['", "']'", "'.'"\r
+  "", "'var'", "':'", "'='", "'*'", "'['", "']'", "'func'", "'('", "')'", \r
+  "','", "'{'", "'}'", "'struct'", "'if'", "'else'", "'switch'", "'case'", \r
+  "'for'", "'while'", "'return'", "'\u003F'", "'.'", "'->'"\r

 };\r
 \r
 std::vector<std::string> TocParser::_symbolicNames = {\r
 };\r
 \r
 std::vector<std::string> TocParser::_symbolicNames = {\r

-  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "BINARY_OPERATOR", \r
-  "INTLIT", "NAME", "WS", "NEWLINE"\r
+  "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", "", \r
+  "", "", "", "", "", "", "POSTFIX_OP", "PREFIX_OP", "BINARY_OP", "INT_LIT", \r
+  "DECIMAL_LIT", "STRING_LIT", "BOOL_LIT", "NAME", "WS", "NEWLINE", "NUMBER"\r

 };\r
 \r
 dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);\r
 };\r
 \r
 dfa::Vocabulary TocParser::_vocabulary(_literalNames, _symbolicNames);\r


@@ -2619,7 +3087,7 @@ TocParser::Initializer::Initializer() {
 \r
   static const uint16_t serializedATNSegment0[] = {\r
     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, \r
 \r
   static const uint16_t serializedATNSegment0[] = {\r
     0x3, 0x608b, 0xa72a, 0x8133, 0xb9ed, 0x417c, 0x3be7, 0x7786, 0x5964, \r

-       0x3, 0x17, 0x104, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, \r
+       0x3, 0x24, 0x14c, 0x4, 0x2, 0x9, 0x2, 0x4, 0x3, 0x9, 0x3, 0x4, 0x4, \r

        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, \r
        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, \r
        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, \r
        0x9, 0x4, 0x4, 0x5, 0x9, 0x5, 0x4, 0x6, 0x9, 0x6, 0x4, 0x7, 0x9, \r
        0x7, 0x4, 0x8, 0x9, 0x8, 0x4, 0x9, 0x9, 0x9, 0x4, 0xa, 0x9, 0xa, \r
        0x4, 0xb, 0x9, 0xb, 0x4, 0xc, 0x9, 0xc, 0x4, 0xd, 0x9, 0xd, 0x4, \r


@@ -2630,167 +3098,220 @@ TocParser::Initializer::Initializer() {
        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, \r
        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, \r
        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, \r
        0x9, 0x1a, 0x4, 0x1b, 0x9, 0x1b, 0x4, 0x1c, 0x9, 0x1c, 0x4, 0x1d, \r
        0x9, 0x1d, 0x4, 0x1e, 0x9, 0x1e, 0x4, 0x1f, 0x9, 0x1f, 0x4, 0x20, \r
        0x9, 0x20, 0x4, 0x21, 0x9, 0x21, 0x4, 0x22, 0x9, 0x22, 0x4, 0x23, \r

-       0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x3, 0x2, \r
-       0x6, 0x2, 0x4c, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, 0x4d, 0x3, 0x2, 0x3, \r
-       0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, 0x55, 0xa, 0x3, 0x3, \r
-       0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, \r
-       0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x60, 0xa, 0x5, 0x3, 0x6, 0x3, 0x6, \r
-       0x3, 0x7, 0x3, 0x7, 0x3, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, \r
-       0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x3, 0x9, \r
-       0x3, 0x9, 0x3, 0x9, 0x7, 0x9, 0x73, 0xa, 0x9, 0xc, 0x9, 0xe, 0x9, \r
-       0x76, 0xb, 0x9, 0x5, 0x9, 0x78, 0xa, 0x9, 0x3, 0xa, 0x3, 0xa, 0x7, \r
-       0xa, 0x7c, 0xa, 0xa, 0xc, 0xa, 0xe, 0xa, 0x7f, 0xb, 0xa, 0x3, 0xa, \r
-       0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, 0x7, 0xb, 0x87, \r
-       0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x8a, 0xb, 0xb, 0x3, 0xb, 0x3, 0xb, \r
-       0x3, 0xc, 0x3, 0xc, 0x5, 0xc, 0x90, 0xa, 0xc, 0x3, 0xd, 0x3, 0xd, \r
-       0x3, 0xe, 0x3, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, 0xf, 0x3, \r
-       0xf, 0x3, 0xf, 0x5, 0xf, 0x9c, 0xa, 0xf, 0x3, 0x10, 0x3, 0x10, 0x3, \r
-       0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x12, 0x3, 0x12, 0x3, \r
-       0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, \r
-       0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, \r
-       0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x3, 0x16, 0x5, \r
-       0x16, 0xb8, 0xa, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, \r
-       0x3, 0x17, 0x3, 0x17, 0x5, 0x17, 0xc0, 0xa, 0x17, 0x3, 0x18, 0x3, \r
-       0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x18, 0x5, 0x18, 0xc7, 0xa, 0x18, \r
-       0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, \r
-       0x5, 0x19, 0xcf, 0xa, 0x19, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, \r
-       0x1a, 0x3, 0x1a, 0x7, 0x1a, 0xd6, 0xa, 0x1a, 0xc, 0x1a, 0xe, 0x1a, \r
-       0xd9, 0xb, 0x1a, 0x5, 0x1a, 0xdb, 0xa, 0x1a, 0x3, 0x1a, 0x3, 0x1a, \r
-       0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, \r
-       0x3, 0x1c, 0x7, 0x1c, 0xe6, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0xe9, \r
-       0xb, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1f, \r
-       0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x20, 0x3, 0x20, \r
-       0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, \r
-       0x3, 0x22, 0x3, 0x22, 0x3, 0x23, 0x3, 0x23, 0x3, 0x24, 0x3, 0x24, \r
-       0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x2, 0x2, 0x26, 0x2, 0x4, 0x6, 0x8, \r
-       0xa, 0xc, 0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, \r
-       0x22, 0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, \r
-       0x38, 0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x2, 0x2, 0x2, \r
-       0x104, 0x2, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4, 0x54, 0x3, 0x2, 0x2, 0x2, \r
-       0x6, 0x56, 0x3, 0x2, 0x2, 0x2, 0x8, 0x59, 0x3, 0x2, 0x2, 0x2, 0xa, \r
-       0x61, 0x3, 0x2, 0x2, 0x2, 0xc, 0x63, 0x3, 0x2, 0x2, 0x2, 0xe, 0x66, \r
-       0x3, 0x2, 0x2, 0x2, 0x10, 0x77, 0x3, 0x2, 0x2, 0x2, 0x12, 0x79, 0x3, \r
-       0x2, 0x2, 0x2, 0x14, 0x82, 0x3, 0x2, 0x2, 0x2, 0x16, 0x8f, 0x3, 0x2, \r
-       0x2, 0x2, 0x18, 0x91, 0x3, 0x2, 0x2, 0x2, 0x1a, 0x93, 0x3, 0x2, 0x2, \r
-       0x2, 0x1c, 0x9b, 0x3, 0x2, 0x2, 0x2, 0x1e, 0x9d, 0x3, 0x2, 0x2, 0x2, \r
-       0x20, 0x9f, 0x3, 0x2, 0x2, 0x2, 0x22, 0xa3, 0x3, 0x2, 0x2, 0x2, 0x24, \r
-       0xa5, 0x3, 0x2, 0x2, 0x2, 0x26, 0xa9, 0x3, 0x2, 0x2, 0x2, 0x28, 0xad, \r
-       0x3, 0x2, 0x2, 0x2, 0x2a, 0xb7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xbf, 0x3, \r
-       0x2, 0x2, 0x2, 0x2e, 0xc6, 0x3, 0x2, 0x2, 0x2, 0x30, 0xce, 0x3, 0x2, \r
-       0x2, 0x2, 0x32, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x34, 0xde, 0x3, 0x2, 0x2, \r
-       0x2, 0x36, 0xe0, 0x3, 0x2, 0x2, 0x2, 0x38, 0xea, 0x3, 0x2, 0x2, 0x2, \r
-       0x3a, 0xec, 0x3, 0x2, 0x2, 0x2, 0x3c, 0xee, 0x3, 0x2, 0x2, 0x2, 0x3e, \r
-       0xf3, 0x3, 0x2, 0x2, 0x2, 0x40, 0xf7, 0x3, 0x2, 0x2, 0x2, 0x42, 0xfb, \r
-       0x3, 0x2, 0x2, 0x2, 0x44, 0xfd, 0x3, 0x2, 0x2, 0x2, 0x46, 0xff, 0x3, \r
-       0x2, 0x2, 0x2, 0x48, 0x101, 0x3, 0x2, 0x2, 0x2, 0x4a, 0x4c, 0x5, \r
-       0x4, 0x3, 0x2, 0x4b, 0x4a, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x4d, 0x3, 0x2, \r
-       0x2, 0x2, 0x4d, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x4d, 0x4e, 0x3, 0x2, 0x2, \r
-       0x2, 0x4e, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x4f, 0x50, 0x7, 0x2, 0x2, 0x3, \r
-       0x50, 0x3, 0x3, 0x2, 0x2, 0x2, 0x51, 0x55, 0x5, 0x6, 0x4, 0x2, 0x52, \r
-       0x55, 0x5, 0xc, 0x7, 0x2, 0x53, 0x55, 0x5, 0x14, 0xb, 0x2, 0x54, \r
-       0x51, 0x3, 0x2, 0x2, 0x2, 0x54, 0x52, 0x3, 0x2, 0x2, 0x2, 0x54, 0x53, \r
-       0x3, 0x2, 0x2, 0x2, 0x55, 0x5, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x7, \r
-       0x3, 0x2, 0x2, 0x57, 0x58, 0x5, 0x8, 0x5, 0x2, 0x58, 0x7, 0x3, 0x2, \r
-       0x2, 0x2, 0x59, 0x5a, 0x5, 0x44, 0x23, 0x2, 0x5a, 0x5b, 0x7, 0x4, \r
-       0x2, 0x2, 0x5b, 0x5c, 0x5, 0xa, 0x6, 0x2, 0x5c, 0x5f, 0x3, 0x2, 0x2, \r
-       0x2, 0x5d, 0x5e, 0x7, 0x5, 0x2, 0x2, 0x5e, 0x60, 0x5, 0x2a, 0x16, \r
-       0x2, 0x5f, 0x5d, 0x3, 0x2, 0x2, 0x2, 0x5f, 0x60, 0x3, 0x2, 0x2, 0x2, \r
-       0x60, 0x9, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x46, 0x24, 0x2, \r
-       0x62, 0xb, 0x3, 0x2, 0x2, 0x2, 0x63, 0x64, 0x7, 0x6, 0x2, 0x2, 0x64, \r
-       0x65, 0x5, 0xe, 0x8, 0x2, 0x65, 0xd, 0x3, 0x2, 0x2, 0x2, 0x66, 0x67, \r
-       0x5, 0x42, 0x22, 0x2, 0x67, 0x68, 0x7, 0x7, 0x2, 0x2, 0x68, 0x69, \r
-       0x5, 0x10, 0x9, 0x2, 0x69, 0x6a, 0x7, 0x8, 0x2, 0x2, 0x6a, 0x6b, \r
-       0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, 0x5, 0xa, 0x6, 0x2, 0x6c, 0x6d, 0x3, \r
-       0x2, 0x2, 0x2, 0x6d, 0x6e, 0x5, 0x12, 0xa, 0x2, 0x6e, 0xf, 0x3, 0x2, \r
-       0x2, 0x2, 0x6f, 0x74, 0x5, 0x8, 0x5, 0x2, 0x70, 0x71, 0x7, 0x9, 0x2, \r
-       0x2, 0x71, 0x73, 0x5, 0x8, 0x5, 0x2, 0x72, 0x70, 0x3, 0x2, 0x2, 0x2, \r
-       0x73, 0x76, 0x3, 0x2, 0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, \r
-       0x75, 0x3, 0x2, 0x2, 0x2, 0x75, 0x78, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, \r
-       0x3, 0x2, 0x2, 0x2, 0x77, 0x6f, 0x3, 0x2, 0x2, 0x2, 0x77, 0x78, 0x3, \r
-       0x2, 0x2, 0x2, 0x78, 0x11, 0x3, 0x2, 0x2, 0x2, 0x79, 0x7d, 0x7, 0xa, \r
-       0x2, 0x2, 0x7a, 0x7c, 0x5, 0x1c, 0xf, 0x2, 0x7b, 0x7a, 0x3, 0x2, \r
-       0x2, 0x2, 0x7c, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x7b, 0x3, 0x2, 0x2, \r
-       0x2, 0x7d, 0x7e, 0x3, 0x2, 0x2, 0x2, 0x7e, 0x80, 0x3, 0x2, 0x2, 0x2, \r
-       0x7f, 0x7d, 0x3, 0x2, 0x2, 0x2, 0x80, 0x81, 0x7, 0xb, 0x2, 0x2, 0x81, \r
-       0x13, 0x3, 0x2, 0x2, 0x2, 0x82, 0x83, 0x7, 0xc, 0x2, 0x2, 0x83, 0x84, \r
-       0x5, 0x48, 0x25, 0x2, 0x84, 0x88, 0x7, 0xa, 0x2, 0x2, 0x85, 0x87, \r
-       0x5, 0x16, 0xc, 0x2, 0x86, 0x85, 0x3, 0x2, 0x2, 0x2, 0x87, 0x8a, \r
-       0x3, 0x2, 0x2, 0x2, 0x88, 0x86, 0x3, 0x2, 0x2, 0x2, 0x88, 0x89, 0x3, \r
-       0x2, 0x2, 0x2, 0x89, 0x8b, 0x3, 0x2, 0x2, 0x2, 0x8a, 0x88, 0x3, 0x2, \r
-       0x2, 0x2, 0x8b, 0x8c, 0x7, 0xb, 0x2, 0x2, 0x8c, 0x15, 0x3, 0x2, 0x2, \r
-       0x2, 0x8d, 0x90, 0x5, 0x18, 0xd, 0x2, 0x8e, 0x90, 0x5, 0x1a, 0xe, \r
-       0x2, 0x8f, 0x8d, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x8e, 0x3, 0x2, 0x2, 0x2, \r
-       0x90, 0x17, 0x3, 0x2, 0x2, 0x2, 0x91, 0x92, 0x5, 0x8, 0x5, 0x2, 0x92, \r
-       0x19, 0x3, 0x2, 0x2, 0x2, 0x93, 0x94, 0x5, 0xe, 0x8, 0x2, 0x94, 0x1b, \r
-       0x3, 0x2, 0x2, 0x2, 0x95, 0x9c, 0x5, 0x6, 0x4, 0x2, 0x96, 0x9c, 0x5, \r
-       0x1e, 0x10, 0x2, 0x97, 0x9c, 0x5, 0x22, 0x12, 0x2, 0x98, 0x9c, 0x5, \r
-       0x26, 0x14, 0x2, 0x99, 0x9c, 0x5, 0x28, 0x15, 0x2, 0x9a, 0x9c, 0x5, \r
-       0x2a, 0x16, 0x2, 0x9b, 0x95, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x96, 0x3, \r
-       0x2, 0x2, 0x2, 0x9b, 0x97, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x98, 0x3, 0x2, \r
-       0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x9a, 0x3, 0x2, 0x2, \r
-       0x2, 0x9c, 0x1d, 0x3, 0x2, 0x2, 0x2, 0x9d, 0x9e, 0x5, 0x20, 0x11, \r
-       0x2, 0x9e, 0x1f, 0x3, 0x2, 0x2, 0x2, 0x9f, 0xa0, 0x7, 0xd, 0x2, 0x2, \r
-       0xa0, 0xa1, 0x5, 0x2a, 0x16, 0x2, 0xa1, 0xa2, 0x5, 0x12, 0xa, 0x2, \r
-       0xa2, 0x21, 0x3, 0x2, 0x2, 0x2, 0xa3, 0xa4, 0x5, 0x24, 0x13, 0x2, \r
-       0xa4, 0x23, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa6, 0x7, 0xe, 0x2, 0x2, 0xa6, \r
-       0xa7, 0x5, 0x2a, 0x16, 0x2, 0xa7, 0xa8, 0x5, 0x12, 0xa, 0x2, 0xa8, \r
-       0x25, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xaa, 0x5, 0x38, 0x1d, 0x2, 0xaa, \r
-       0xab, 0x7, 0x5, 0x2, 0x2, 0xab, 0xac, 0x5, 0x2a, 0x16, 0x2, 0xac, \r
-       0x27, 0x3, 0x2, 0x2, 0x2, 0xad, 0xae, 0x7, 0xf, 0x2, 0x2, 0xae, 0xaf, \r
-       0x5, 0x2a, 0x16, 0x2, 0xaf, 0x29, 0x3, 0x2, 0x2, 0x2, 0xb0, 0xb8, \r
-       0x5, 0x32, 0x1a, 0x2, 0xb1, 0xb8, 0x5, 0x3a, 0x1e, 0x2, 0xb2, 0xb8, \r
-       0x5, 0x38, 0x1d, 0x2, 0xb3, 0xb8, 0x5, 0x3c, 0x1f, 0x2, 0xb4, 0xb8, \r
-       0x5, 0x3e, 0x20, 0x2, 0xb5, 0xb8, 0x5, 0x40, 0x21, 0x2, 0xb6, 0xb8, \r
-       0x5, 0x34, 0x1b, 0x2, 0xb7, 0xb0, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb1, \r
-       0x3, 0x2, 0x2, 0x2, 0xb7, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb3, 0x3, \r
-       0x2, 0x2, 0x2, 0xb7, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb7, 0xb5, 0x3, 0x2, \r
-       0x2, 0x2, 0xb7, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb8, 0x2b, 0x3, 0x2, 0x2, \r
-       0x2, 0xb9, 0xc0, 0x5, 0x32, 0x1a, 0x2, 0xba, 0xc0, 0x5, 0x3a, 0x1e, \r
-       0x2, 0xbb, 0xc0, 0x5, 0x38, 0x1d, 0x2, 0xbc, 0xc0, 0x5, 0x3c, 0x1f, \r
-       0x2, 0xbd, 0xc0, 0x5, 0x3e, 0x20, 0x2, 0xbe, 0xc0, 0x5, 0x40, 0x21, \r
-       0x2, 0xbf, 0xb9, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xba, 0x3, 0x2, 0x2, 0x2, \r
-       0xbf, 0xbb, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbc, 0x3, 0x2, 0x2, 0x2, 0xbf, \r
-       0xbd, 0x3, 0x2, 0x2, 0x2, 0xbf, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc0, 0x2d, \r
-       0x3, 0x2, 0x2, 0x2, 0xc1, 0xc7, 0x5, 0x32, 0x1a, 0x2, 0xc2, 0xc7, \r
-       0x5, 0x3a, 0x1e, 0x2, 0xc3, 0xc7, 0x5, 0x38, 0x1d, 0x2, 0xc4, 0xc7, \r
-       0x5, 0x3e, 0x20, 0x2, 0xc5, 0xc7, 0x5, 0x40, 0x21, 0x2, 0xc6, 0xc1, \r
-       0x3, 0x2, 0x2, 0x2, 0xc6, 0xc2, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc3, 0x3, \r
-       0x2, 0x2, 0x2, 0xc6, 0xc4, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xc5, 0x3, 0x2, \r
-       0x2, 0x2, 0xc7, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xcf, 0x5, 0x32, \r
-       0x1a, 0x2, 0xc9, 0xcf, 0x5, 0x3a, 0x1e, 0x2, 0xca, 0xcf, 0x5, 0x38, \r
-       0x1d, 0x2, 0xcb, 0xcf, 0x5, 0x3c, 0x1f, 0x2, 0xcc, 0xcf, 0x5, 0x40, \r
-       0x21, 0x2, 0xcd, 0xcf, 0x5, 0x34, 0x1b, 0x2, 0xce, 0xc8, 0x3, 0x2, \r
-       0x2, 0x2, 0xce, 0xc9, 0x3, 0x2, 0x2, 0x2, 0xce, 0xca, 0x3, 0x2, 0x2, \r
-       0x2, 0xce, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xce, 0xcc, 0x3, 0x2, 0x2, 0x2, \r
-       0xce, 0xcd, 0x3, 0x2, 0x2, 0x2, 0xcf, 0x31, 0x3, 0x2, 0x2, 0x2, 0xd0, \r
-       0xd1, 0x5, 0x42, 0x22, 0x2, 0xd1, 0xda, 0x7, 0x7, 0x2, 0x2, 0xd2, \r
-       0xd7, 0x5, 0x2a, 0x16, 0x2, 0xd3, 0xd4, 0x7, 0x9, 0x2, 0x2, 0xd4, \r
-       0xd6, 0x5, 0x2a, 0x16, 0x2, 0xd5, 0xd3, 0x3, 0x2, 0x2, 0x2, 0xd6, \r
-       0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd8, \r
-       0x3, 0x2, 0x2, 0x2, 0xd8, 0xdb, 0x3, 0x2, 0x2, 0x2, 0xd9, 0xd7, 0x3, \r
-       0x2, 0x2, 0x2, 0xda, 0xd2, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x3, 0x2, \r
-       0x2, 0x2, 0xdb, 0xdc, 0x3, 0x2, 0x2, 0x2, 0xdc, 0xdd, 0x7, 0x8, 0x2, \r
-       0x2, 0xdd, 0x33, 0x3, 0x2, 0x2, 0x2, 0xde, 0xdf, 0x5, 0x36, 0x1c, \r
-       0x2, 0xdf, 0x35, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x5, 0x2c, 0x17, \r
-       0x2, 0xe1, 0xe2, 0x7, 0x13, 0x2, 0x2, 0xe2, 0xe7, 0x5, 0x2c, 0x17, \r
-       0x2, 0xe3, 0xe4, 0x7, 0x13, 0x2, 0x2, 0xe4, 0xe6, 0x5, 0x2c, 0x17, \r
-       0x2, 0xe5, 0xe3, 0x3, 0x2, 0x2, 0x2, 0xe6, 0xe9, 0x3, 0x2, 0x2, 0x2, \r
-       0xe7, 0xe5, 0x3, 0x2, 0x2, 0x2, 0xe7, 0xe8, 0x3, 0x2, 0x2, 0x2, 0xe8, \r
-       0x37, 0x3, 0x2, 0x2, 0x2, 0xe9, 0xe7, 0x3, 0x2, 0x2, 0x2, 0xea, 0xeb, \r
-       0x5, 0x44, 0x23, 0x2, 0xeb, 0x39, 0x3, 0x2, 0x2, 0x2, 0xec, 0xed, \r
-       0x7, 0x14, 0x2, 0x2, 0xed, 0x3b, 0x3, 0x2, 0x2, 0x2, 0xee, 0xef, \r
-       0x5, 0x2e, 0x18, 0x2, 0xef, 0xf0, 0x7, 0x10, 0x2, 0x2, 0xf0, 0xf1, \r
-       0x5, 0x2a, 0x16, 0x2, 0xf1, 0xf2, 0x7, 0x11, 0x2, 0x2, 0xf2, 0x3d, \r
-       0x3, 0x2, 0x2, 0x2, 0xf3, 0xf4, 0x5, 0x38, 0x1d, 0x2, 0xf4, 0xf5, \r
-       0x7, 0x12, 0x2, 0x2, 0xf5, 0xf6, 0x5, 0x38, 0x1d, 0x2, 0xf6, 0x3f, \r
-       0x3, 0x2, 0x2, 0x2, 0xf7, 0xf8, 0x7, 0x7, 0x2, 0x2, 0xf8, 0xf9, 0x5, \r
-       0x2a, 0x16, 0x2, 0xf9, 0xfa, 0x7, 0x8, 0x2, 0x2, 0xfa, 0x41, 0x3, \r
-       0x2, 0x2, 0x2, 0xfb, 0xfc, 0x7, 0x15, 0x2, 0x2, 0xfc, 0x43, 0x3, \r
-       0x2, 0x2, 0x2, 0xfd, 0xfe, 0x7, 0x15, 0x2, 0x2, 0xfe, 0x45, 0x3, \r
-       0x2, 0x2, 0x2, 0xff, 0x100, 0x7, 0x15, 0x2, 0x2, 0x100, 0x47, 0x3, \r
-       0x2, 0x2, 0x2, 0x101, 0x102, 0x7, 0x15, 0x2, 0x2, 0x102, 0x49, 0x3, \r
-       0x2, 0x2, 0x2, 0x12, 0x4d, 0x54, 0x5f, 0x74, 0x77, 0x7d, 0x88, 0x8f, \r
-       0x9b, 0xb7, 0xbf, 0xc6, 0xce, 0xd7, 0xda, 0xe7, \r
+       0x9, 0x23, 0x4, 0x24, 0x9, 0x24, 0x4, 0x25, 0x9, 0x25, 0x4, 0x26, \r
+       0x9, 0x26, 0x4, 0x27, 0x9, 0x27, 0x4, 0x28, 0x9, 0x28, 0x4, 0x29, \r
+       0x9, 0x29, 0x3, 0x2, 0x6, 0x2, 0x54, 0xa, 0x2, 0xd, 0x2, 0xe, 0x2, \r
+       0x55, 0x3, 0x2, 0x3, 0x2, 0x3, 0x3, 0x3, 0x3, 0x3, 0x3, 0x5, 0x3, \r
+       0x5d, 0xa, 0x3, 0x3, 0x4, 0x3, 0x4, 0x3, 0x4, 0x3, 0x5, 0x3, 0x5, \r
+       0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x3, 0x5, 0x5, 0x5, 0x68, 0xa, 0x5, \r
+       0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, 0x6, 0x3, \r
+       0x6, 0x3, 0x7, 0x3, 0x7, 0x7, 0x7, 0x73, 0xa, 0x7, 0xc, 0x7, 0xe, \r
+       0x7, 0x76, 0xb, 0x7, 0x3, 0x8, 0x3, 0x8, 0x3, 0x8, 0x5, 0x8, 0x7b, \r
+       0xa, 0x8, 0x3, 0x8, 0x5, 0x8, 0x7e, 0xa, 0x8, 0x3, 0x9, 0x3, 0x9, \r
+       0x3, 0x9, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, \r
+       0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xa, 0x3, 0xb, 0x3, 0xb, 0x3, 0xb, \r
+       0x7, 0xb, 0x8f, 0xa, 0xb, 0xc, 0xb, 0xe, 0xb, 0x92, 0xb, 0xb, 0x5, \r
+       0xb, 0x94, 0xa, 0xb, 0x3, 0xc, 0x3, 0xc, 0x7, 0xc, 0x98, 0xa, 0xc, \r
+       0xc, 0xc, 0xe, 0xc, 0x9b, 0xb, 0xc, 0x3, 0xc, 0x3, 0xc, 0x3, 0xd, \r
+       0x3, 0xd, 0x3, 0xd, 0x3, 0xd, 0x7, 0xd, 0xa3, 0xa, 0xd, 0xc, 0xd, \r
+       0xe, 0xd, 0xa6, 0xb, 0xd, 0x3, 0xd, 0x3, 0xd, 0x3, 0xe, 0x3, 0xe, \r
+       0x5, 0xe, 0xac, 0xa, 0xe, 0x3, 0xf, 0x3, 0xf, 0x3, 0x10, 0x3, 0x10, \r
+       0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, 0x3, 0x11, \r
+       0x3, 0x11, 0x3, 0x11, 0x5, 0x11, 0xba, 0xa, 0x11, 0x3, 0x12, 0x3, \r
+       0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, 0x12, 0x3, \r
+       0x12, 0x7, 0x12, 0xc4, 0xa, 0x12, 0xc, 0x12, 0xe, 0x12, 0xc7, 0xb, \r
+       0x12, 0x3, 0x12, 0x3, 0x12, 0x5, 0x12, 0xcb, 0xa, 0x12, 0x3, 0x13, \r
+       0x3, 0x13, 0x3, 0x13, 0x3, 0x13, 0x3, 0x14, 0x3, 0x14, 0x3, 0x14, \r
+       0x3, 0x14, 0x3, 0x14, 0x7, 0x14, 0xd6, 0xa, 0x14, 0xc, 0x14, 0xe, \r
+       0x14, 0xd9, 0xb, 0x14, 0x3, 0x14, 0x3, 0x14, 0x3, 0x15, 0x3, 0x15, \r
+       0x3, 0x15, 0x5, 0x15, 0xe0, 0xa, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, \r
+       0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x15, 0x3, 0x16, 0x3, 0x16, 0x3, \r
+       0x16, 0x3, 0x16, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, 0x17, 0x3, \r
+       0x18, 0x3, 0x18, 0x3, 0x18, 0x3, 0x19, 0x3, 0x19, 0x3, 0x19, 0x3, \r
+       0x19, 0x3, 0x19, 0x3, 0x19, 0x5, 0x19, 0xf9, 0xa, 0x19, 0x3, 0x1a, \r
+       0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x3, 0x1a, 0x5, 0x1a, 0x100, 0xa, \r
+       0x1a, 0x3, 0x1b, 0x3, 0x1b, 0x3, 0x1b, 0x5, 0x1b, 0x105, 0xa, 0x1b, \r
+       0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x7, 0x1c, \r
+       0x10c, 0xa, 0x1c, 0xc, 0x1c, 0xe, 0x1c, 0x10f, 0xb, 0x1c, 0x5, 0x1c, \r
+       0x111, 0xa, 0x1c, 0x3, 0x1c, 0x3, 0x1c, 0x3, 0x1d, 0x3, 0x1d, 0x3, \r
+       0x1d, 0x3, 0x1d, 0x5, 0x1d, 0x119, 0xa, 0x1d, 0x3, 0x1e, 0x3, 0x1e, \r
+       0x3, 0x1e, 0x3, 0x1e, 0x3, 0x1e, 0x7, 0x1e, 0x120, 0xa, 0x1e, 0xc, \r
+       0x1e, 0xe, 0x1e, 0x123, 0xb, 0x1e, 0x3, 0x1f, 0x3, 0x1f, 0x3, 0x1f, \r
+       0x3, 0x20, 0x3, 0x20, 0x3, 0x20, 0x3, 0x21, 0x3, 0x21, 0x3, 0x21, \r
+       0x3, 0x21, 0x3, 0x21, 0x3, 0x21, 0x3, 0x22, 0x3, 0x22, 0x3, 0x23, \r
+       0x3, 0x23, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, 0x3, 0x24, \r
+       0x3, 0x24, 0x3, 0x24, 0x6, 0x24, 0x13c, 0xa, 0x24, 0xd, 0x24, 0xe, \r
+       0x24, 0x13d, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x25, 0x3, 0x26, \r
+       0x3, 0x26, 0x3, 0x27, 0x3, 0x27, 0x3, 0x28, 0x3, 0x28, 0x3, 0x29, \r
+       0x3, 0x29, 0x3, 0x29, 0x2, 0x2, 0x2a, 0x2, 0x4, 0x6, 0x8, 0xa, 0xc, \r
+       0xe, 0x10, 0x12, 0x14, 0x16, 0x18, 0x1a, 0x1c, 0x1e, 0x20, 0x22, \r
+       0x24, 0x26, 0x28, 0x2a, 0x2c, 0x2e, 0x30, 0x32, 0x34, 0x36, 0x38, \r
+       0x3a, 0x3c, 0x3e, 0x40, 0x42, 0x44, 0x46, 0x48, 0x4a, 0x4c, 0x4e, \r
+       0x50, 0x2, 0x4, 0x3, 0x2, 0x1d, 0x20, 0x3, 0x2, 0x18, 0x19, 0x2, \r
+       0x14d, 0x2, 0x53, 0x3, 0x2, 0x2, 0x2, 0x4, 0x5c, 0x3, 0x2, 0x2, 0x2, \r
+       0x6, 0x5e, 0x3, 0x2, 0x2, 0x2, 0x8, 0x61, 0x3, 0x2, 0x2, 0x2, 0xa, \r
+       0x69, 0x3, 0x2, 0x2, 0x2, 0xc, 0x70, 0x3, 0x2, 0x2, 0x2, 0xe, 0x7d, \r
+       0x3, 0x2, 0x2, 0x2, 0x10, 0x7f, 0x3, 0x2, 0x2, 0x2, 0x12, 0x82, 0x3, \r
+       0x2, 0x2, 0x2, 0x14, 0x93, 0x3, 0x2, 0x2, 0x2, 0x16, 0x95, 0x3, 0x2, \r
+       0x2, 0x2, 0x18, 0x9e, 0x3, 0x2, 0x2, 0x2, 0x1a, 0xab, 0x3, 0x2, 0x2, \r
+       0x2, 0x1c, 0xad, 0x3, 0x2, 0x2, 0x2, 0x1e, 0xaf, 0x3, 0x2, 0x2, 0x2, \r
+       0x20, 0xb9, 0x3, 0x2, 0x2, 0x2, 0x22, 0xbb, 0x3, 0x2, 0x2, 0x2, 0x24, \r
+       0xcc, 0x3, 0x2, 0x2, 0x2, 0x26, 0xd0, 0x3, 0x2, 0x2, 0x2, 0x28, 0xdc, \r
+       0x3, 0x2, 0x2, 0x2, 0x2a, 0xe7, 0x3, 0x2, 0x2, 0x2, 0x2c, 0xeb, 0x3, \r
+       0x2, 0x2, 0x2, 0x2e, 0xef, 0x3, 0x2, 0x2, 0x2, 0x30, 0xf8, 0x3, 0x2, \r
+       0x2, 0x2, 0x32, 0xff, 0x3, 0x2, 0x2, 0x2, 0x34, 0x104, 0x3, 0x2, \r
+       0x2, 0x2, 0x36, 0x106, 0x3, 0x2, 0x2, 0x2, 0x38, 0x118, 0x3, 0x2, \r
+       0x2, 0x2, 0x3a, 0x11a, 0x3, 0x2, 0x2, 0x2, 0x3c, 0x124, 0x3, 0x2, \r
+       0x2, 0x2, 0x3e, 0x127, 0x3, 0x2, 0x2, 0x2, 0x40, 0x12a, 0x3, 0x2, \r
+       0x2, 0x2, 0x42, 0x130, 0x3, 0x2, 0x2, 0x2, 0x44, 0x132, 0x3, 0x2, \r
+       0x2, 0x2, 0x46, 0x134, 0x3, 0x2, 0x2, 0x2, 0x48, 0x13f, 0x3, 0x2, \r
+       0x2, 0x2, 0x4a, 0x143, 0x3, 0x2, 0x2, 0x2, 0x4c, 0x145, 0x3, 0x2, \r
+       0x2, 0x2, 0x4e, 0x147, 0x3, 0x2, 0x2, 0x2, 0x50, 0x149, 0x3, 0x2, \r
+       0x2, 0x2, 0x52, 0x54, 0x5, 0x4, 0x3, 0x2, 0x53, 0x52, 0x3, 0x2, 0x2, \r
+       0x2, 0x54, 0x55, 0x3, 0x2, 0x2, 0x2, 0x55, 0x53, 0x3, 0x2, 0x2, 0x2, \r
+       0x55, 0x56, 0x3, 0x2, 0x2, 0x2, 0x56, 0x57, 0x3, 0x2, 0x2, 0x2, 0x57, \r
+       0x58, 0x7, 0x2, 0x2, 0x3, 0x58, 0x3, 0x3, 0x2, 0x2, 0x2, 0x59, 0x5d, \r
+       0x5, 0x6, 0x4, 0x2, 0x5a, 0x5d, 0x5, 0x10, 0x9, 0x2, 0x5b, 0x5d, \r
+       0x5, 0x18, 0xd, 0x2, 0x5c, 0x59, 0x3, 0x2, 0x2, 0x2, 0x5c, 0x5a, \r
+       0x3, 0x2, 0x2, 0x2, 0x5c, 0x5b, 0x3, 0x2, 0x2, 0x2, 0x5d, 0x5, 0x3, \r
+       0x2, 0x2, 0x2, 0x5e, 0x5f, 0x7, 0x3, 0x2, 0x2, 0x5f, 0x60, 0x5, 0x8, \r
+       0x5, 0x2, 0x60, 0x7, 0x3, 0x2, 0x2, 0x2, 0x61, 0x62, 0x5, 0x4c, 0x27, \r
+       0x2, 0x62, 0x63, 0x7, 0x4, 0x2, 0x2, 0x63, 0x64, 0x5, 0xc, 0x7, 0x2, \r
+       0x64, 0x67, 0x3, 0x2, 0x2, 0x2, 0x65, 0x66, 0x7, 0x5, 0x2, 0x2, 0x66, \r
+       0x68, 0x5, 0x30, 0x19, 0x2, 0x67, 0x65, 0x3, 0x2, 0x2, 0x2, 0x67, \r
+       0x68, 0x3, 0x2, 0x2, 0x2, 0x68, 0x9, 0x3, 0x2, 0x2, 0x2, 0x69, 0x6a, \r
+       0x5, 0x4c, 0x27, 0x2, 0x6a, 0x6b, 0x7, 0x4, 0x2, 0x2, 0x6b, 0x6c, \r
+       0x5, 0xc, 0x7, 0x2, 0x6c, 0x6d, 0x3, 0x2, 0x2, 0x2, 0x6d, 0x6e, 0x7, \r
+       0x5, 0x2, 0x2, 0x6e, 0x6f, 0x5, 0x30, 0x19, 0x2, 0x6f, 0xb, 0x3, \r
+       0x2, 0x2, 0x2, 0x70, 0x74, 0x5, 0x4e, 0x28, 0x2, 0x71, 0x73, 0x5, \r
+       0xe, 0x8, 0x2, 0x72, 0x71, 0x3, 0x2, 0x2, 0x2, 0x73, 0x76, 0x3, 0x2, \r
+       0x2, 0x2, 0x74, 0x72, 0x3, 0x2, 0x2, 0x2, 0x74, 0x75, 0x3, 0x2, 0x2, \r
+       0x2, 0x75, 0xd, 0x3, 0x2, 0x2, 0x2, 0x76, 0x74, 0x3, 0x2, 0x2, 0x2, \r
+       0x77, 0x7e, 0x7, 0x6, 0x2, 0x2, 0x78, 0x7a, 0x7, 0x7, 0x2, 0x2, 0x79, \r
+       0x7b, 0x7, 0x24, 0x2, 0x2, 0x7a, 0x79, 0x3, 0x2, 0x2, 0x2, 0x7a, \r
+       0x7b, 0x3, 0x2, 0x2, 0x2, 0x7b, 0x7c, 0x3, 0x2, 0x2, 0x2, 0x7c, 0x7e, \r
+       0x7, 0x8, 0x2, 0x2, 0x7d, 0x77, 0x3, 0x2, 0x2, 0x2, 0x7d, 0x78, 0x3, \r
+       0x2, 0x2, 0x2, 0x7e, 0xf, 0x3, 0x2, 0x2, 0x2, 0x7f, 0x80, 0x7, 0x9, \r
+       0x2, 0x2, 0x80, 0x81, 0x5, 0x12, 0xa, 0x2, 0x81, 0x11, 0x3, 0x2, \r
+       0x2, 0x2, 0x82, 0x83, 0x5, 0x4a, 0x26, 0x2, 0x83, 0x84, 0x7, 0xa, \r
+       0x2, 0x2, 0x84, 0x85, 0x5, 0x14, 0xb, 0x2, 0x85, 0x86, 0x7, 0xb, \r
+       0x2, 0x2, 0x86, 0x87, 0x7, 0x4, 0x2, 0x2, 0x87, 0x88, 0x5, 0xc, 0x7, \r
+       0x2, 0x88, 0x89, 0x3, 0x2, 0x2, 0x2, 0x89, 0x8a, 0x5, 0x16, 0xc, \r
+       0x2, 0x8a, 0x13, 0x3, 0x2, 0x2, 0x2, 0x8b, 0x90, 0x5, 0x8, 0x5, 0x2, \r
+       0x8c, 0x8d, 0x7, 0xc, 0x2, 0x2, 0x8d, 0x8f, 0x5, 0x8, 0x5, 0x2, 0x8e, \r
+       0x8c, 0x3, 0x2, 0x2, 0x2, 0x8f, 0x92, 0x3, 0x2, 0x2, 0x2, 0x90, 0x8e, \r
+       0x3, 0x2, 0x2, 0x2, 0x90, 0x91, 0x3, 0x2, 0x2, 0x2, 0x91, 0x94, 0x3, \r
+       0x2, 0x2, 0x2, 0x92, 0x90, 0x3, 0x2, 0x2, 0x2, 0x93, 0x8b, 0x3, 0x2, \r
+       0x2, 0x2, 0x93, 0x94, 0x3, 0x2, 0x2, 0x2, 0x94, 0x15, 0x3, 0x2, 0x2, \r
+       0x2, 0x95, 0x99, 0x7, 0xd, 0x2, 0x2, 0x96, 0x98, 0x5, 0x20, 0x11, \r
+       0x2, 0x97, 0x96, 0x3, 0x2, 0x2, 0x2, 0x98, 0x9b, 0x3, 0x2, 0x2, 0x2, \r
+       0x99, 0x97, 0x3, 0x2, 0x2, 0x2, 0x99, 0x9a, 0x3, 0x2, 0x2, 0x2, 0x9a, \r
+       0x9c, 0x3, 0x2, 0x2, 0x2, 0x9b, 0x99, 0x3, 0x2, 0x2, 0x2, 0x9c, 0x9d, \r
+       0x7, 0xe, 0x2, 0x2, 0x9d, 0x17, 0x3, 0x2, 0x2, 0x2, 0x9e, 0x9f, 0x7, \r
+       0xf, 0x2, 0x2, 0x9f, 0xa0, 0x5, 0x50, 0x29, 0x2, 0xa0, 0xa4, 0x7, \r
+       0xd, 0x2, 0x2, 0xa1, 0xa3, 0x5, 0x1a, 0xe, 0x2, 0xa2, 0xa1, 0x3, \r
+       0x2, 0x2, 0x2, 0xa3, 0xa6, 0x3, 0x2, 0x2, 0x2, 0xa4, 0xa2, 0x3, 0x2, \r
+       0x2, 0x2, 0xa4, 0xa5, 0x3, 0x2, 0x2, 0x2, 0xa5, 0xa7, 0x3, 0x2, 0x2, \r
+       0x2, 0xa6, 0xa4, 0x3, 0x2, 0x2, 0x2, 0xa7, 0xa8, 0x7, 0xe, 0x2, 0x2, \r
+       0xa8, 0x19, 0x3, 0x2, 0x2, 0x2, 0xa9, 0xac, 0x5, 0x1c, 0xf, 0x2, \r
+       0xaa, 0xac, 0x5, 0x1e, 0x10, 0x2, 0xab, 0xa9, 0x3, 0x2, 0x2, 0x2, \r
+       0xab, 0xaa, 0x3, 0x2, 0x2, 0x2, 0xac, 0x1b, 0x3, 0x2, 0x2, 0x2, 0xad, \r
+       0xae, 0x5, 0x8, 0x5, 0x2, 0xae, 0x1d, 0x3, 0x2, 0x2, 0x2, 0xaf, 0xb0, \r
+       0x5, 0x12, 0xa, 0x2, 0xb0, 0x1f, 0x3, 0x2, 0x2, 0x2, 0xb1, 0xba, \r
+       0x5, 0x6, 0x4, 0x2, 0xb2, 0xba, 0x5, 0x22, 0x12, 0x2, 0xb3, 0xba, \r
+       0x5, 0x24, 0x13, 0x2, 0xb4, 0xba, 0x5, 0x28, 0x15, 0x2, 0xb5, 0xba, \r
+       0x5, 0x2a, 0x16, 0x2, 0xb6, 0xba, 0x5, 0x2c, 0x17, 0x2, 0xb7, 0xba, \r
+       0x5, 0x2e, 0x18, 0x2, 0xb8, 0xba, 0x5, 0x30, 0x19, 0x2, 0xb9, 0xb1, \r
+       0x3, 0x2, 0x2, 0x2, 0xb9, 0xb2, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb3, 0x3, \r
+       0x2, 0x2, 0x2, 0xb9, 0xb4, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb5, 0x3, 0x2, \r
+       0x2, 0x2, 0xb9, 0xb6, 0x3, 0x2, 0x2, 0x2, 0xb9, 0xb7, 0x3, 0x2, 0x2, \r
+       0x2, 0xb9, 0xb8, 0x3, 0x2, 0x2, 0x2, 0xba, 0x21, 0x3, 0x2, 0x2, 0x2, \r
+       0xbb, 0xbc, 0x7, 0x10, 0x2, 0x2, 0xbc, 0xbd, 0x5, 0x30, 0x19, 0x2, \r
+       0xbd, 0xc5, 0x5, 0x16, 0xc, 0x2, 0xbe, 0xbf, 0x7, 0x11, 0x2, 0x2, \r
+       0xbf, 0xc0, 0x7, 0x10, 0x2, 0x2, 0xc0, 0xc1, 0x5, 0x30, 0x19, 0x2, \r
+       0xc1, 0xc2, 0x5, 0x16, 0xc, 0x2, 0xc2, 0xc4, 0x3, 0x2, 0x2, 0x2, \r
+       0xc3, 0xbe, 0x3, 0x2, 0x2, 0x2, 0xc4, 0xc7, 0x3, 0x2, 0x2, 0x2, 0xc5, \r
+       0xc3, 0x3, 0x2, 0x2, 0x2, 0xc5, 0xc6, 0x3, 0x2, 0x2, 0x2, 0xc6, 0xca, \r
+       0x3, 0x2, 0x2, 0x2, 0xc7, 0xc5, 0x3, 0x2, 0x2, 0x2, 0xc8, 0xc9, 0x7, \r
+       0x11, 0x2, 0x2, 0xc9, 0xcb, 0x5, 0x16, 0xc, 0x2, 0xca, 0xc8, 0x3, \r
+       0x2, 0x2, 0x2, 0xca, 0xcb, 0x3, 0x2, 0x2, 0x2, 0xcb, 0x23, 0x3, 0x2, \r
+       0x2, 0x2, 0xcc, 0xcd, 0x7, 0x12, 0x2, 0x2, 0xcd, 0xce, 0x5, 0x42, \r
+       0x22, 0x2, 0xce, 0xcf, 0x5, 0x26, 0x14, 0x2, 0xcf, 0x25, 0x3, 0x2, \r
+       0x2, 0x2, 0xd0, 0xd7, 0x7, 0xd, 0x2, 0x2, 0xd1, 0xd2, 0x7, 0x13, \r
+       0x2, 0x2, 0xd2, 0xd3, 0x5, 0x30, 0x19, 0x2, 0xd3, 0xd4, 0x5, 0x16, \r
+       0xc, 0x2, 0xd4, 0xd6, 0x3, 0x2, 0x2, 0x2, 0xd5, 0xd1, 0x3, 0x2, 0x2, \r
+       0x2, 0xd6, 0xd9, 0x3, 0x2, 0x2, 0x2, 0xd7, 0xd5, 0x3, 0x2, 0x2, 0x2, \r
+       0xd7, 0xd8, 0x3, 0x2, 0x2, 0x2, 0xd8, 0xda, 0x3, 0x2, 0x2, 0x2, 0xd9, \r
+       0xd7, 0x3, 0x2, 0x2, 0x2, 0xda, 0xdb, 0x7, 0xe, 0x2, 0x2, 0xdb, 0x27, \r
+       0x3, 0x2, 0x2, 0x2, 0xdc, 0xdf, 0x7, 0x14, 0x2, 0x2, 0xdd, 0xe0, \r
+       0x5, 0xa, 0x6, 0x2, 0xde, 0xe0, 0x5, 0x2c, 0x17, 0x2, 0xdf, 0xdd, \r
+       0x3, 0x2, 0x2, 0x2, 0xdf, 0xde, 0x3, 0x2, 0x2, 0x2, 0xe0, 0xe1, 0x3, \r
+       0x2, 0x2, 0x2, 0xe1, 0xe2, 0x7, 0xc, 0x2, 0x2, 0xe2, 0xe3, 0x5, 0x30, \r
+       0x19, 0x2, 0xe3, 0xe4, 0x7, 0xc, 0x2, 0x2, 0xe4, 0xe5, 0x5, 0x30, \r
+       0x19, 0x2, 0xe5, 0xe6, 0x5, 0x16, 0xc, 0x2, 0xe6, 0x29, 0x3, 0x2, \r
+       0x2, 0x2, 0xe7, 0xe8, 0x7, 0x15, 0x2, 0x2, 0xe8, 0xe9, 0x5, 0x30, \r
+       0x19, 0x2, 0xe9, 0xea, 0x5, 0x16, 0xc, 0x2, 0xea, 0x2b, 0x3, 0x2, \r
+       0x2, 0x2, 0xeb, 0xec, 0x5, 0x42, 0x22, 0x2, 0xec, 0xed, 0x7, 0x5, \r
+       0x2, 0x2, 0xed, 0xee, 0x5, 0x30, 0x19, 0x2, 0xee, 0x2d, 0x3, 0x2, \r
+       0x2, 0x2, 0xef, 0xf0, 0x7, 0x16, 0x2, 0x2, 0xf0, 0xf1, 0x5, 0x30, \r
+       0x19, 0x2, 0xf1, 0x2f, 0x3, 0x2, 0x2, 0x2, 0xf2, 0xf9, 0x5, 0x36, \r
+       0x1c, 0x2, 0xf3, 0xf9, 0x5, 0x44, 0x23, 0x2, 0xf4, 0xf9, 0x5, 0x42, \r
+       0x22, 0x2, 0xf5, 0xf9, 0x5, 0x48, 0x25, 0x2, 0xf6, 0xf9, 0x5, 0x46, \r
+       0x24, 0x2, 0xf7, 0xf9, 0x5, 0x38, 0x1d, 0x2, 0xf8, 0xf2, 0x3, 0x2, \r
+       0x2, 0x2, 0xf8, 0xf3, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf4, 0x3, 0x2, 0x2, \r
+       0x2, 0xf8, 0xf5, 0x3, 0x2, 0x2, 0x2, 0xf8, 0xf6, 0x3, 0x2, 0x2, 0x2, \r
+       0xf8, 0xf7, 0x3, 0x2, 0x2, 0x2, 0xf9, 0x31, 0x3, 0x2, 0x2, 0x2, 0xfa, \r
+       0x100, 0x5, 0x36, 0x1c, 0x2, 0xfb, 0x100, 0x5, 0x44, 0x23, 0x2, 0xfc, \r
+       0x100, 0x5, 0x42, 0x22, 0x2, 0xfd, 0x100, 0x5, 0x48, 0x25, 0x2, 0xfe, \r
+       0x100, 0x5, 0x46, 0x24, 0x2, 0xff, 0xfa, 0x3, 0x2, 0x2, 0x2, 0xff, \r
+       0xfb, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfc, 0x3, 0x2, 0x2, 0x2, 0xff, 0xfd, \r
+       0x3, 0x2, 0x2, 0x2, 0xff, 0xfe, 0x3, 0x2, 0x2, 0x2, 0x100, 0x33, \r
+       0x3, 0x2, 0x2, 0x2, 0x101, 0x105, 0x5, 0x36, 0x1c, 0x2, 0x102, 0x105, \r
+       0x5, 0x42, 0x22, 0x2, 0x103, 0x105, 0x5, 0x48, 0x25, 0x2, 0x104, \r
+       0x101, 0x3, 0x2, 0x2, 0x2, 0x104, 0x102, 0x3, 0x2, 0x2, 0x2, 0x104, \r
+       0x103, 0x3, 0x2, 0x2, 0x2, 0x105, 0x35, 0x3, 0x2, 0x2, 0x2, 0x106, \r
+       0x107, 0x5, 0x4a, 0x26, 0x2, 0x107, 0x110, 0x7, 0xa, 0x2, 0x2, 0x108, \r
+       0x10d, 0x5, 0x30, 0x19, 0x2, 0x109, 0x10a, 0x7, 0xc, 0x2, 0x2, 0x10a, \r
+       0x10c, 0x5, 0x30, 0x19, 0x2, 0x10b, 0x109, 0x3, 0x2, 0x2, 0x2, 0x10c, \r
+       0x10f, 0x3, 0x2, 0x2, 0x2, 0x10d, 0x10b, 0x3, 0x2, 0x2, 0x2, 0x10d, \r
+       0x10e, 0x3, 0x2, 0x2, 0x2, 0x10e, 0x111, 0x3, 0x2, 0x2, 0x2, 0x10f, \r
+       0x10d, 0x3, 0x2, 0x2, 0x2, 0x110, 0x108, 0x3, 0x2, 0x2, 0x2, 0x110, \r
+       0x111, 0x3, 0x2, 0x2, 0x2, 0x111, 0x112, 0x3, 0x2, 0x2, 0x2, 0x112, \r
+       0x113, 0x7, 0xb, 0x2, 0x2, 0x113, 0x37, 0x3, 0x2, 0x2, 0x2, 0x114, \r
+       0x119, 0x5, 0x3a, 0x1e, 0x2, 0x115, 0x119, 0x5, 0x3c, 0x1f, 0x2, \r
+       0x116, 0x119, 0x5, 0x3e, 0x20, 0x2, 0x117, 0x119, 0x5, 0x40, 0x21, \r
+       0x2, 0x118, 0x114, 0x3, 0x2, 0x2, 0x2, 0x118, 0x115, 0x3, 0x2, 0x2, \r
+       0x2, 0x118, 0x116, 0x3, 0x2, 0x2, 0x2, 0x118, 0x117, 0x3, 0x2, 0x2, \r
+       0x2, 0x119, 0x39, 0x3, 0x2, 0x2, 0x2, 0x11a, 0x11b, 0x5, 0x32, 0x1a, \r
+       0x2, 0x11b, 0x11c, 0x7, 0x1c, 0x2, 0x2, 0x11c, 0x121, 0x5, 0x32, \r
+       0x1a, 0x2, 0x11d, 0x11e, 0x7, 0x1c, 0x2, 0x2, 0x11e, 0x120, 0x5, \r
+       0x32, 0x1a, 0x2, 0x11f, 0x11d, 0x3, 0x2, 0x2, 0x2, 0x120, 0x123, \r
+       0x3, 0x2, 0x2, 0x2, 0x121, 0x11f, 0x3, 0x2, 0x2, 0x2, 0x121, 0x122, \r
+       0x3, 0x2, 0x2, 0x2, 0x122, 0x3b, 0x3, 0x2, 0x2, 0x2, 0x123, 0x121, \r
+       0x3, 0x2, 0x2, 0x2, 0x124, 0x125, 0x7, 0x1b, 0x2, 0x2, 0x125, 0x126, \r
+       0x5, 0x32, 0x1a, 0x2, 0x126, 0x3d, 0x3, 0x2, 0x2, 0x2, 0x127, 0x128, \r
+       0x5, 0x32, 0x1a, 0x2, 0x128, 0x129, 0x7, 0x1a, 0x2, 0x2, 0x129, 0x3f, \r
+       0x3, 0x2, 0x2, 0x2, 0x12a, 0x12b, 0x5, 0x32, 0x1a, 0x2, 0x12b, 0x12c, \r
+       0x7, 0x17, 0x2, 0x2, 0x12c, 0x12d, 0x5, 0x30, 0x19, 0x2, 0x12d, 0x12e, \r
+       0x7, 0x4, 0x2, 0x2, 0x12e, 0x12f, 0x5, 0x30, 0x19, 0x2, 0x12f, 0x41, \r
+       0x3, 0x2, 0x2, 0x2, 0x130, 0x131, 0x5, 0x4c, 0x27, 0x2, 0x131, 0x43, \r
+       0x3, 0x2, 0x2, 0x2, 0x132, 0x133, 0x9, 0x2, 0x2, 0x2, 0x133, 0x45, \r
+       0x3, 0x2, 0x2, 0x2, 0x134, 0x13b, 0x5, 0x34, 0x1b, 0x2, 0x135, 0x136, \r
+       0x9, 0x3, 0x2, 0x2, 0x136, 0x13c, 0x5, 0x42, 0x22, 0x2, 0x137, 0x138, \r
+       0x7, 0x7, 0x2, 0x2, 0x138, 0x139, 0x5, 0x30, 0x19, 0x2, 0x139, 0x13a, \r
+       0x7, 0x8, 0x2, 0x2, 0x13a, 0x13c, 0x3, 0x2, 0x2, 0x2, 0x13b, 0x135, \r
+       0x3, 0x2, 0x2, 0x2, 0x13b, 0x137, 0x3, 0x2, 0x2, 0x2, 0x13c, 0x13d, \r
+       0x3, 0x2, 0x2, 0x2, 0x13d, 0x13b, 0x3, 0x2, 0x2, 0x2, 0x13d, 0x13e, \r
+       0x3, 0x2, 0x2, 0x2, 0x13e, 0x47, 0x3, 0x2, 0x2, 0x2, 0x13f, 0x140, \r
+       0x7, 0xa, 0x2, 0x2, 0x140, 0x141, 0x5, 0x30, 0x19, 0x2, 0x141, 0x142, \r
+       0x7, 0xb, 0x2, 0x2, 0x142, 0x49, 0x3, 0x2, 0x2, 0x2, 0x143, 0x144, \r
+       0x7, 0x21, 0x2, 0x2, 0x144, 0x4b, 0x3, 0x2, 0x2, 0x2, 0x145, 0x146, \r
+       0x7, 0x21, 0x2, 0x2, 0x146, 0x4d, 0x3, 0x2, 0x2, 0x2, 0x147, 0x148, \r
+       0x7, 0x21, 0x2, 0x2, 0x148, 0x4f, 0x3, 0x2, 0x2, 0x2, 0x149, 0x14a, \r
+       0x7, 0x21, 0x2, 0x2, 0x14a, 0x51, 0x3, 0x2, 0x2, 0x2, 0x1b, 0x55, \r
+       0x5c, 0x67, 0x74, 0x7a, 0x7d, 0x90, 0x93, 0x99, 0xa4, 0xab, 0xb9, \r
+       0xc5, 0xca, 0xd7, 0xdf, 0xf8, 0xff, 0x104, 0x10d, 0x110, 0x118, 0x121, \r
+       0x13b, 0x13d, \r

   };\r
 \r
   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,\r
   };\r
 \r
   _serializedATN.insert(_serializedATN.end(), serializedATNSegment0,\r