From e4e884d1104cb0a8a87afe538ce64001d30a9191 Mon Sep 17 00:00:00 2001
From: xensik <xensik@pm.me>
Date: Tue, 24 Jan 2023 12:53:39 +0100
Subject: [PATCH] slash paths and compound stmt

---
 gen/gsc/parser.ypp     |   30 +-
 gen/t6/parser.ypp      |    4 +-
 src/gsc/compiler.cpp   |   36 +-
 src/gsc/compiler.hpp   |    2 +
 src/gsc/decompiler.cpp |  170 ++--
 src/gsc/decompiler.hpp |    2 +
 src/gsc/misc/ast.cpp   |   11 +-
 src/gsc/misc/ast.hpp   |   27 +-
 src/gsc/parser.cpp     |  535 ++++++-------
 src/gsc/parser.hpp     |   86 +-
 src/gsc/source.cpp     |   72 +-
 src/gsc/source.hpp     |    1 +
 src/t6/parser.cpp      | 1678 ++++++++++++++++++++--------------------
 src/t6/parser.hpp      |    2 +-
 14 files changed, 1374 insertions(+), 1282 deletions(-)

diff --git a/gen/gsc/parser.ypp b/gen/gsc/parser.ypp
index cd05b8ab..69e1a1b6 100644
--- a/gen/gsc/parser.ypp
+++ b/gen/gsc/parser.ypp
@@ -162,7 +162,7 @@ namespace xsk::gsc
 %type <stmt_list::ptr>             stmt_list
 %type <stmt_list::ptr>             stmt_or_dev_list
 %type <stmt_dev::ptr>              stmt_dev
-%type <stmt_list::ptr>             stmt_block
+%type <stmt_comp::ptr>             stmt_comp
 %type <stmt_expr::ptr>             stmt_expr
 %type <stmt_call::ptr>             stmt_call
 %type <stmt_assign::ptr>           stmt_assign
@@ -310,12 +310,12 @@ decl_usingtree
     ;
 
 decl_function
-    : expr_identifier LPAREN expr_parameters RPAREN stmt_block
+    : expr_identifier LPAREN expr_parameters RPAREN stmt_comp
         { lexer.ban_header(@$); $$ = make_decl_function(@$, std::move($1), std::move($3), std::move($5)); }
     ;
 
 stmt
-    : stmt_block             { $$.as_list = std::move($1); }
+    : stmt_comp              { $$.as_comp = std::move($1); }
     | stmt_call              { $$.as_call = std::move($1); }
     | stmt_assign            { $$.as_assign = std::move($1); }
     | stmt_endon             { $$.as_endon = std::move($1); }
@@ -366,9 +366,9 @@ stmt_dev
     | DEVBEGIN DEVEND { $$ = make_stmt_dev(@$, make_stmt_list(@$)); }
     ;
 
-stmt_block
-    : LBRACE stmt_or_dev_list RBRACE { $$ = std::move($2); }
-    | LBRACE RBRACE { $$ = make_stmt_list(@$); }
+stmt_comp
+    : LBRACE stmt_or_dev_list RBRACE { $$ = make_stmt_comp(@$, std::move($2)); }
+    | LBRACE RBRACE { $$ = make_stmt_comp(@$, make_stmt_list(@$)); }
     ;
 
 stmt_expr
@@ -481,7 +481,7 @@ stmt_foreach
     ;
 
 stmt_switch
-    : SWITCH LPAREN expr RPAREN stmt_block
+    : SWITCH LPAREN expr RPAREN stmt_comp
         { $$ = make_stmt_switch(@$, std::move($3), std::move($5)); 
           parse_switch(*$$);
         }
@@ -930,14 +930,14 @@ void parser::error(location const& loc, std::string const& msg)
 
 auto parse_switch(stmt_switch& stm) -> void
 {
-    auto body = make_stmt_list(stm.body->loc());
+    auto body = make_stmt_list(stm.body->block->loc());
     auto current_case = stmt{ nullptr };
 
-    auto num = stm.body->list.size();
+    auto num = stm.body->block->list.size();
 
     for (auto i = 0u; i < num; i++)
     {
-        auto& entry = stm.body->list[0];
+        auto& entry = stm.body->block->list[0];
 
         if (entry == node::stmt_case || entry == node::stmt_default)
         {
@@ -946,8 +946,8 @@ auto parse_switch(stmt_switch& stm) -> void
                 body->list.push_back(std::move(current_case));
             }
 
-            current_case = std::move(stm.body->list[0]);
-            stm.body->list.erase(stm.body->list.begin());
+            current_case = std::move(stm.body->block->list[0]);
+            stm.body->block->list.erase(stm.body->block->list.begin());
         }
         else
         {
@@ -956,12 +956,12 @@ auto parse_switch(stmt_switch& stm) -> void
                 if (current_case == node::stmt_case)
                 {
                     current_case.as_case->body->list.push_back(std::move(entry));
-                    stm.body->list.erase(stm.body->list.begin());
+                    stm.body->block->list.erase(stm.body->block->list.begin());
                 }
                 else
                 {
                     current_case.as_default->body->list.push_back(std::move(entry));
-                    stm.body->list.erase(stm.body->list.begin());
+                    stm.body->block->list.erase(stm.body->block->list.begin());
                 }
             }
             else
@@ -976,7 +976,7 @@ auto parse_switch(stmt_switch& stm) -> void
         body->list.push_back(std::move(current_case));
     }
 
-    stm.body = std::move(body);
+    stm.body->block = std::move(body);
 }
 
 } // namespace xsk::gsc
diff --git a/gen/t6/parser.ypp b/gen/t6/parser.ypp
index c14a47e6..39e2367c 100644
--- a/gen/t6/parser.ypp
+++ b/gen/t6/parser.ypp
@@ -967,7 +967,9 @@ expr_identifier
     ;
 
 expr_path
-    : IDENTIFIER
+    : PATH DIV IDENTIFIER
+        { $$ = std::make_unique<ast::expr_path>(@$, $1 + "/" + $3); };
+    | IDENTIFIER
         { $$ = std::make_unique<ast::expr_path>(@$, $1); };
     | PATH
         { $$ = std::make_unique<ast::expr_path>(@$, $1); };
diff --git a/src/gsc/compiler.cpp b/src/gsc/compiler.cpp
index 580671a6..9b71040c 100644
--- a/src/gsc/compiler.cpp
+++ b/src/gsc/compiler.cpp
@@ -123,7 +123,7 @@ auto compiler::emit_decl_function(decl_function const& func) -> void
     auto& scp = scopes_.at(func.body.get());
 
     emit_expr_parameters(*func.params, *scp);
-    emit_stmt_list(*func.body, *scp, true);
+    emit_stmt_comp(*func.body, *scp, true);
     emit_opcode(opcode::OP_End);
 
     function_->size = index_ - function_->index;
@@ -137,6 +137,9 @@ auto compiler::emit_stmt(stmt const& stm, scope& scp, bool last) -> void
         case node::stmt_list:
             emit_stmt_list(*stm.as_list, scp, last);
             break;
+        case node::stmt_comp:
+            emit_stmt_comp(*stm.as_comp, scp, last);
+            break;
         case node::stmt_dev:
             emit_stmt_dev(*stm.as_dev, scp, last);
             break;
@@ -228,9 +231,14 @@ auto compiler::emit_stmt_list(stmt_list const& stm, scope& scp, bool last) -> vo
     }
 }
 
+auto compiler::emit_stmt_comp(stmt_comp const& stm, scope& scp, bool last) -> void
+{
+    emit_stmt_list(*stm.block, scp, last);
+}
+
 auto compiler::emit_stmt_dev(stmt_dev const& stm, scope& scp, bool last) -> void
 {
-    emit_stmt_list(*stm.body, scp, last);
+    emit_stmt_list(*stm.block, scp, last);
 }
 
 auto compiler::emit_stmt_expr(stmt_expr const& stm, scope& scp) -> void
@@ -754,16 +762,16 @@ auto compiler::emit_stmt_switch(stmt_switch const& stm, scope& scp) -> void
     can_break_ = true;
 
     auto data = std::vector<std::string>{};
-    data.push_back(fmt::format("{}", stm.body->list.size()));
+    data.push_back(fmt::format("{}", stm.body->block->list.size()));
 
     auto type = switch_type::none;
     auto loc_default = std::string{};
     auto has_default = false;
     scope* default_ctx = nullptr;
 
-    for (auto i = 0u; i < stm.body->list.size(); i++)
+    for (auto i = 0u; i < stm.body->block->list.size(); i++)
     {
-        auto const& entry = stm.body->list[i];
+        auto const& entry = stm.body->block->list[i];
 
         if (entry == node::stmt_case)
         {
@@ -860,7 +868,7 @@ auto compiler::emit_stmt_switch(stmt_switch const& stm, scope& scp) -> void
 
     emit_opcode(opcode::OP_endswitch, data);
 
-    auto offset = static_cast<u32>(((ctx_->engine() == engine::iw9) ? 8 : 7) * stm.body->list.size());
+    auto offset = static_cast<u32>(((ctx_->engine() == engine::iw9) ? 8 : 7) * stm.body->block->list.size());
     function_->instructions.back()->size += offset;
     index_ += offset;
 
@@ -2258,7 +2266,7 @@ auto compiler::process_function(decl_function const& func) -> void
     auto& scp_body = ins.first->second;
 
     process_expr_parameters(*func.params, *scp_body);
-    process_stmt_list(*func.body, *scp_body);
+    process_stmt_comp(*func.body, *scp_body);
 }
 
 auto compiler::process_stmt(stmt const& stm, scope& scp) -> void
@@ -2268,6 +2276,9 @@ auto compiler::process_stmt(stmt const& stm, scope& scp) -> void
         case node::stmt_list:
             process_stmt_list(*stm.as_list, scp);
             break;
+        case node::stmt_comp:
+            process_stmt_comp(*stm.as_comp, scp);
+            break;
         case node::stmt_dev:
             process_stmt_dev(*stm.as_dev, scp);
             break;
@@ -2336,9 +2347,14 @@ auto compiler::process_stmt_list(stmt_list const& stm, scope& scp) -> void
     }
 }
 
+auto compiler::process_stmt_comp(stmt_comp const& stm, scope& scp) -> void
+{
+    process_stmt_list(*stm.block, scp);
+}
+
 auto compiler::process_stmt_dev(stmt_dev const& stm, scope& scp) -> void
 {
-    process_stmt_list(*stm.body, scp);
+    process_stmt_list(*stm.block, scp);
 }
 
 auto compiler::process_stmt_expr(stmt_expr const& stm, scope& scp) -> void
@@ -2607,9 +2623,9 @@ auto compiler::process_stmt_switch(stmt_switch const& stm, scope& scp) -> void
     auto old_breaks = break_blks_;
     break_blks_.clear();
 
-    for (auto i = 0u; i < stm.body->list.size(); i++)
+    for (auto i = 0u; i < stm.body->block->list.size(); i++)
     {
-        auto& entry = stm.body->list[i];
+        auto& entry = stm.body->block->list[i];
 
         if (entry == node::stmt_case)
         {
diff --git a/src/gsc/compiler.hpp b/src/gsc/compiler.hpp
index ca7403b2..619ad711 100644
--- a/src/gsc/compiler.hpp
+++ b/src/gsc/compiler.hpp
@@ -40,6 +40,7 @@ private:
     auto emit_decl_function(decl_function const& func) -> void;
     auto emit_stmt(stmt const& stm, scope& scp, bool last) -> void;
     auto emit_stmt_list(stmt_list const& stm, scope& scp, bool last) -> void;
+    auto emit_stmt_comp(stmt_comp const& stm, scope& scp, bool last) -> void;
     auto emit_stmt_dev(stmt_dev const& stm, scope& scp, bool last) -> void;
     auto emit_stmt_expr(stmt_expr const& stm, scope& scp) -> void;
     auto emit_stmt_call(stmt_call const& stm, scope& scp) -> void;
@@ -119,6 +120,7 @@ private:
     auto process_function(decl_function const& func) -> void;
     auto process_stmt(stmt const& stm, scope& scp) -> void;
     auto process_stmt_list(stmt_list const& stm, scope& scp) -> void;
+    auto process_stmt_comp(stmt_comp const& stm, scope& scp) -> void;
     auto process_stmt_dev(stmt_dev const& stm, scope& scp) -> void;
     auto process_stmt_expr(stmt_expr const& stm, scope& scp) -> void;
     auto process_stmt_assign(stmt_assign const& stm, scope& scp) -> void;
diff --git a/src/gsc/decompiler.cpp b/src/gsc/decompiler.cpp
index d7cddd5f..325a9f89 100644
--- a/src/gsc/decompiler.cpp
+++ b/src/gsc/decompiler.cpp
@@ -39,7 +39,7 @@ auto decompiler::decompile_function(function const& func) -> void
     auto loc = location{ nullptr, static_cast<location::counter_type>(func.index) };
     auto name = make_expr_identifier(loc, func.name);
     auto prms = make_expr_parameters(loc);
-    auto body = make_stmt_list(loc);
+    auto body = make_stmt_comp(loc, make_stmt_list(loc));
     func_ = make_decl_function(loc, std::move(name), std::move(prms), std::move(body));
 
     for (auto const& inst : func.instructions)
@@ -53,10 +53,10 @@ auto decompiler::decompile_function(function const& func) -> void
     }
 
     locs_.last = true;
-    locs_.end = func_->body->list.back().label();
-    func_->body->list.pop_back();
+    locs_.end = func_->body->block->list.back().label();
+    func_->body->block->list.pop_back();
 
-    decompile_statements(*func_->body);
+    decompile_statements(*func_->body->block);
     process_function(*func_);
 
     program_->declarations.push_back(decl{ move(func_) });
@@ -72,13 +72,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
     {
         case opcode::OP_End:
         {
-            func_->body->list.push_back(stmt{ make_stmt_return(loc, expr{ make_node(loc) }) });
+            func_->body->block->list.push_back(stmt{ make_stmt_return(loc, expr{ make_node(loc) }) });
             break;
         }
         case opcode::OP_Return:
         {
             auto value = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_stmt_return(value.loc(), std::move(value)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_return(value.loc(), std::move(value)) });
             break;
         }
         case opcode::OP_GetZero:
@@ -216,13 +216,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             }
             else
             {
-                func_->body->list.push_back(stmt{ make_asm_create(loc, inst.data[0]) });
+                func_->body->block->list.push_back(stmt{ make_asm_create(loc, inst.data[0]) });
             }
             break;
         }
         case opcode::OP_RemoveLocalVariables:
         {
-            func_->body->list.push_back(stmt{ make_asm_remove(loc, inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_remove(loc, inst.data[0]) });
             break;
         }
         case opcode::OP_EvalLocalVariableCached0:
@@ -310,7 +310,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto lvalue = expr{ make_expr_array(loc, std::move(obj), std::move(key)) };
             auto rvalue = expr{ make_expr_undefined(loc) };
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_AddArray:
@@ -932,7 +932,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
         case opcode::OP_DecTop:
         {
             auto exp = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_stmt_call(exp.loc(), std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_call(exp.loc(), std::move(exp)) });
             break;
         }
         case opcode::OP_inc:
@@ -1062,17 +1062,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
         case opcode::OP_wait:
         {
             auto exp = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_stmt_wait(exp.loc(), std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_wait(exp.loc(), std::move(exp)) });
             break;
         }
         case opcode::OP_waittillFrameEnd:
         {
-            func_->body->list.push_back(stmt{ make_stmt_waittillframeend(loc) });
+            func_->body->block->list.push_back(stmt{ make_stmt_waittillframeend(loc) });
             break;
         }
         case opcode::OP_waitframe:
         {
-            func_->body->list.push_back(stmt{ make_stmt_waitframe(loc) });
+            func_->body->block->list.push_back(stmt{ make_stmt_waitframe(loc) });
             break;
         }
         case opcode::OP_waittill:
@@ -1098,7 +1098,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
                 args->list.push_back(std::move(arg));
             }
 
-            func_->body->list.push_back(stmt{ make_stmt_waittillmatch(loc, std::move(obj), std::move(event), std::move(args)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_waittillmatch(loc, std::move(obj), std::move(event), std::move(args)) });
             break;
         }
         case opcode::OP_clearparams:
@@ -1121,7 +1121,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
                     in_waittill_ = false;
                 }
 
-                func_->body->list.push_back(stmt{ std::move(arg) });
+                func_->body->block->list.push_back(stmt{ std::move(arg) });
             }
             break;
         }
@@ -1140,14 +1140,14 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
                 loc = var->loc();
             }
 
-            func_->body->list.push_back(stmt{ make_stmt_notify(loc, std::move(obj), std::move(event), std::move(args)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_notify(loc, std::move(obj), std::move(event), std::move(args)) });
             break;
         }
         case opcode::OP_endon:
         {
             auto obj = expr{ std::move(stack_.top()) }; stack_.pop();
             auto event = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_stmt_endon(event.loc(), std::move(obj), std::move(event)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_endon(event.loc(), std::move(obj), std::move(event)) });
             break;
         }
         case opcode::OP_voidCodepos:
@@ -1233,7 +1233,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto field = expr{ make_expr_field(loc, std::move(obj), std::move(name)) };
             auto undef = expr{ make_expr_undefined(loc) };
             auto exp = expr{ make_expr_assign_equal(loc, std::move(field), std::move(undef)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SafeCreateVariableFieldCached:
@@ -1278,7 +1278,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto field = make_expr_identifier(loc, inst.data[0]);
             auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SetVariableField:
@@ -1288,18 +1288,18 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
 
             if (lvalue == node::expr_increment)
             {
-                func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
+                func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
             }
             else if (lvalue == node::expr_decrement)
             {
-                func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
+                func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(lvalue)) });
             }
             else
             {
                 auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
                 loc = rvalue.loc();
                 auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-                func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+                func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             }
             break;
         }
@@ -1311,7 +1311,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto field = make_expr_identifier(loc, inst.data[0]);
             auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SetSelfFieldVariableField:
@@ -1322,7 +1322,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto field = make_expr_identifier(loc, inst.data[0]);
             auto lvalue = expr{ make_expr_field(loc, std::move(obj), std::move(field)) };
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SetLocalVariableFieldCached0:
@@ -1331,7 +1331,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
             loc = rvalue.loc();
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SetNewLocalVariableFieldCached0:
@@ -1340,17 +1340,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
             loc = rvalue.loc();
 
-            if (func_->body->list.size() > 0)
+            if (func_->body->block->list.size() > 0)
             {
                 std::vector<std::string> vars;
 
-                while (func_->body->list.back() == node::asm_create)
+                while (func_->body->block->list.back() == node::asm_create)
                 {
-                    auto& entry = func_->body->list.back();
+                    auto& entry = func_->body->block->list.back();
                     if (loc.begin.line < entry.loc().begin.line)
                     {
                         vars.push_back(entry.as_asm_create->index);
-                        func_->body->list.pop_back();
+                        func_->body->block->list.pop_back();
                         continue;
                     }
                     break;
@@ -1361,7 +1361,7 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             }
 
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_SetLocalVariableFieldCached:
@@ -1370,17 +1370,17 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
             loc = rvalue.loc();
             auto exp = expr{ make_expr_assign_equal(loc, std::move(lvalue), std::move(rvalue)) };
-            func_->body->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
+            func_->body->block->list.push_back(stmt{ make_stmt_assign(loc, std::move(exp)) });
             break;
         }
         case opcode::OP_ClearLocalVariableFieldCached:
         {
-            func_->body->list.push_back(stmt{ make_asm_clear(loc, inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_clear(loc, inst.data[0]) });
             break;
         }
         case opcode::OP_ClearLocalVariableFieldCached0:
         {
-            func_->body->list.push_back(stmt{ make_asm_clear(loc, "0") });
+            func_->body->block->list.push_back(stmt{ make_asm_clear(loc, "0") });
             break;
         }
         case opcode::OP_EvalLocalVariableObjectCached:
@@ -1403,23 +1403,23 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
         case opcode::OP_switch:
         {
             auto test = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_asm_switch(test.loc(), std::move(test), inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_switch(test.loc(), std::move(test), inst.data[0]) });
             break;
         }
         case opcode::OP_endswitch:
         {
-            func_->body->list.push_back(stmt{ make_asm_endswitch(loc, inst.data) });
+            func_->body->block->list.push_back(stmt{ make_asm_endswitch(loc, inst.data) });
             break;
         }
         case opcode::OP_jump:
         {
-            func_->body->list.push_back(stmt{ make_asm_jmp(loc, inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_jmp(loc, inst.data[0]) });
             if (stack_.size() != 0) tern_labels_.push_back(inst.data[0]);
             break;
         }
         case opcode::OP_jumpback:
         {
-            func_->body->list.push_back(stmt{ make_asm_jmp_back(loc, inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_jmp_back(loc, inst.data[0]) });
             break;
         }
         case opcode::OP_JumpOnTrue:
@@ -1427,13 +1427,13 @@ auto decompiler::decompile_instruction(instruction const& inst) -> void
             auto lvalue = expr{ std::move(stack_.top()) }; stack_.pop();
             loc = lvalue.loc();
             auto test = expr{ make_expr_not(loc, std::move(lvalue)) };
-            func_->body->list.push_back(stmt{ make_asm_jmp_cond(loc, std::move(test), inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_jmp_cond(loc, std::move(test), inst.data[0]) });
             break;
         }
         case opcode::OP_JumpOnFalse:
         {
             auto test = expr{ std::move(stack_.top()) }; stack_.pop();
-            func_->body->list.push_back(stmt{ make_asm_jmp_cond(test.loc(), std::move(test), inst.data[0]) });
+            func_->body->block->list.push_back(stmt{ make_asm_jmp_cond(test.loc(), std::move(test), inst.data[0]) });
             break;
         }
         case opcode::OP_JumpOnTrueExpr:
@@ -1548,9 +1548,9 @@ auto decompiler::decompile_expressions(instruction const& inst) -> void
             auto rvalue = expr{ std::move(stack_.top()) }; stack_.pop();
             auto lvalue = expr{ std::move(stack_.top()) }; stack_.pop();
 
-            func_->body->list.pop_back();
-            auto stm = std::move(func_->body->list.back());
-            func_->body->list.pop_back();
+            func_->body->block->list.pop_back();
+            auto stm = std::move(func_->body->block->list.back());
+            func_->body->block->list.pop_back();
 
             if (stm == node::asm_jmp_cond)
             {
@@ -1870,7 +1870,7 @@ auto decompiler::decompile_if(stmt_list& stm, usize begin, usize end) -> void
 
     decompile_statements(*body);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ std::move(body) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
 }
 
 auto decompiler::decompile_ifelse(stmt_list& stm, usize begin, usize end) -> void
@@ -1916,7 +1916,7 @@ auto decompiler::decompile_ifelse(stmt_list& stm, usize begin, usize end) -> voi
 
     decompile_statements(*body_else);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ std::move(body_if) }, stmt{ std::move(body_else) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }, stmt{ make_stmt_comp(loc, std::move(body_else)) }) });
 }
 
 auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) -> void
@@ -1946,7 +1946,7 @@ auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) ->
 
     if (begin == stm.list.size())
     {
-        stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ std::move(body_if) }) });
+        stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_if(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }) });
     }
     else
     {
@@ -1967,7 +1967,7 @@ auto decompiler::decompile_ifelse_end(stmt_list& stm, usize begin, usize end) ->
 
         decompile_statements(*body_else);
         locs_ = save;
-        stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ std::move(body_if) }, stmt{ std::move(body_else) }) });
+        stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_ifelse(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body_if)) }, stmt{ make_stmt_comp(loc, std::move(body_else)) }) });
     }
 }
 
@@ -1993,7 +1993,7 @@ auto decompiler::decompile_inf(stmt_list& stm, usize begin, usize end) -> void
 
     decompile_statements(*body);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt{ make_node(loc) }, expr{ make_node(loc) }, stmt{ make_node(loc) }, stmt{ std::move(body) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt{ make_node(loc) }, expr{ make_node(loc) }, stmt{ make_node(loc) }, stmt{ make_stmt_comp(loc, std::move(body)) }) });
 }
 
 auto decompiler::decompile_loop(stmt_list& stm, usize start, usize end) -> void
@@ -2086,7 +2086,7 @@ auto decompiler::decompile_while(stmt_list& stm, usize begin, usize end) -> void
 
     decompile_statements(*body);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_while(loc, std::move(test), stmt{ std::move(body) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_while(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
 }
 
 auto decompiler::decompile_dowhile(stmt_list& stm, usize begin, usize end) -> void
@@ -2115,7 +2115,7 @@ auto decompiler::decompile_dowhile(stmt_list& stm, usize begin, usize end) -> vo
 
     decompile_statements(*body);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_dowhile(loc, std::move(test), stmt{ std::move(body) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_dowhile(loc, std::move(test), stmt{ make_stmt_comp(loc, std::move(body)) }) });
 }
 
 auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
@@ -2130,7 +2130,6 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
 
     auto loc = stm.list[begin].loc();
     auto init = make_stmt_list(loc);
-    init->is_expr = true;
 
     while (stm.list[begin] != node::asm_jmp_cond)
     {
@@ -2144,7 +2143,6 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
     end -= 2 + init->list.size();
 
     auto iter = make_stmt_list(loc);
-    iter->is_expr = true;
     iter->list.push_back(std::move(stm.list[end]));
     stm.list.erase(stm.list.begin() + end);
     stm.list.erase(stm.list.begin() + end);
@@ -2159,7 +2157,7 @@ auto decompiler::decompile_for(stmt_list& stm, usize begin, usize end) -> void
 
     decompile_statements(*body);
     locs_ = save;
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt { std::move(init) }, std::move(test), stmt {std::move(iter) }, stmt{ std::move(body) }) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_for(loc, stmt { std::move(init) }, std::move(test), stmt { std::move(iter) }, stmt{ make_stmt_comp(loc, std::move(body)) }) });
 }
 
 auto decompiler::decompile_foreach(stmt_list& stm, usize begin, usize end) -> void
@@ -2244,7 +2242,7 @@ auto decompiler::decompile_foreach(stmt_list& stm, usize begin, usize end) -> vo
     decompile_statements(*body);
     locs_ = save;
     body->list.insert(body->list.begin(), stmt{ std::move(init) });
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_foreach(loc, std::move(container), std::move(value), std::move(index), std::move(array), std::move(key), stmt{ std::move(body) }, (ctx_->props() & props::foreach) ? use_index : use_key) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_foreach(loc, std::move(container), std::move(value), std::move(index), std::move(array), std::move(key), stmt{ make_stmt_comp(loc, std::move(body)) }, (ctx_->props() & props::foreach) ? use_index : use_key) });
 }
 
 auto decompiler::decompile_switch(stmt_list& stm, usize begin, usize end) -> void
@@ -2361,7 +2359,7 @@ auto decompiler::decompile_switch(stmt_list& stm, usize begin, usize end) -> voi
         body->list.push_back(std::move(temp));
     }
 
-    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_switch(loc, std::move(test), std::move(body)) });
+    stm.list.insert(stm.list.begin() + begin, stmt{ make_stmt_switch(loc, std::move(test), make_stmt_comp(loc, std::move(body))) });
 }
 
 auto decompiler::find_location_reference(stmt_list const& stm, usize begin, usize end, std::string const& loc) -> bool
@@ -2416,7 +2414,7 @@ auto decompiler::process_function(decl_function& func) -> void
         scp_body->create_count++;
     }
 
-    process_stmt_list(*func.body, *scp_body);
+    process_stmt_comp(*func.body, *scp_body);
 }
 
 auto decompiler::process_stmt(stmt& stm, scope& scp) -> void
@@ -2426,6 +2424,12 @@ auto decompiler::process_stmt(stmt& stm, scope& scp) -> void
         case node::stmt_list:
             process_stmt_list(*stm.as_list, scp);
             break;
+        case node::stmt_comp:
+            process_stmt_comp(*stm.as_comp, scp);
+            break;
+        case node::stmt_dev:
+            process_stmt_dev(*stm.as_dev, scp);
+            break;
         case node::stmt_expr:
             process_stmt_expr(*stm.as_expr, scp);
             break;
@@ -2507,6 +2511,16 @@ auto decompiler::process_stmt_list(stmt_list& stm, scope& scp) -> void
     }
 }
 
+auto decompiler::process_stmt_comp(stmt_comp& stm, scope& scp) -> void
+{
+    process_stmt_list(*stm.block, scp);
+}
+
+auto decompiler::process_stmt_dev(stmt_dev& stm, scope& scp) -> void
+{
+    process_stmt_list(*stm.block, scp);
+}
+
 auto decompiler::process_stmt_expr(stmt_expr& stm, scope& scp) -> void
 {
     switch (stm.value.kind())
@@ -2624,9 +2638,9 @@ auto decompiler::process_stmt_if(stmt_if& stm, scope& scp) -> void
 
     process_stmt(stm.body, *scp_then);
 
-    if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
+    if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.body = std::move(stm.body.as_list->list.back());
+        stm.body = std::move(stm.body.as_comp->block->list.back());
     }
 }
 
@@ -2668,14 +2682,14 @@ auto decompiler::process_stmt_ifelse(stmt_ifelse& stm, scope& scp) -> void
 
     scp.append(childs);
 
-    if (stm.stmt_if.as_list->list.size() == 1 && !stm.stmt_if.as_list->list[0].as_node->is_special_stmt())
+    if (stm.stmt_if.as_comp->block->list.size() == 1 && !stm.stmt_if.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.stmt_if = std::move(stm.stmt_if.as_list->list.back());
+        stm.stmt_if = std::move(stm.stmt_if.as_comp->block->list.back());
     }
 
-    if (stm.stmt_else.as_list->list.size() == 1 && !stm.stmt_else.as_list->list[0].as_node->is_special_stmt_noif())
+    if (stm.stmt_else.as_comp->block->list.size() == 1 && !stm.stmt_else.as_comp->block->list[0].as_node->is_special_stmt_noif())
     {
-        stm.stmt_else = std::move(stm.stmt_else.as_list->list.back());
+        stm.stmt_else = std::move(stm.stmt_else.as_comp->block->list.back());
     }
 }
 
@@ -2692,9 +2706,9 @@ auto decompiler::process_stmt_while(stmt_while& stm, scope& scp) -> void
     if (stm.test == node::null)
         scp.append_dec(scp_body);
 
-    if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
+    if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.body = std::move(stm.body.as_list->list.back());
+        stm.body = std::move(stm.body.as_comp->block->list.back());
     }
 }
 
@@ -2711,9 +2725,9 @@ auto decompiler::process_stmt_dowhile(stmt_dowhile& stm, scope& scp) -> void
     if (stm.test == node::null)
         scp.append_dec(scp_body);
 
-    if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
+    if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.body = std::move(stm.body.as_list->list.back());
+        stm.body = std::move(stm.body.as_comp->block->list.back());
     }
 }
 
@@ -2723,6 +2737,11 @@ auto decompiler::process_stmt_for(stmt_for& stm, scope& scp) -> void
 
     process_stmt(stm.init, scp);
 
+    if (stm.init == node::stmt_list && stm.init.as_list->list[0] == node::stmt_assign)
+    {
+        stm.init = stmt{ make_stmt_expr(stm.init.loc(), std::move(stm.init.as_list->list[0].as_assign->value)) };
+    }
+
     scp.transfer_dec(scp_body);
 
     process_expr(stm.test, scp);
@@ -2731,12 +2750,17 @@ auto decompiler::process_stmt_for(stmt_for& stm, scope& scp) -> void
 
     process_stmt(stm.iter, scp);
 
+    if (stm.iter == node::stmt_list && stm.iter.as_list->list[0] == node::stmt_assign)
+    {
+        stm.iter = stmt{ make_stmt_expr(stm.iter.loc(), std::move(stm.iter.as_list->list[0].as_assign->value)) };
+    }
+
     if (stm.test == node::null)
         scp.append_dec(scp_body);
 
-    if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
+    if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.body = std::move(stm.body.as_list->list.back());
+        stm.body = std::move(stm.body.as_comp->block->list.back());
     }
 }
 
@@ -2753,18 +2777,18 @@ auto decompiler::process_stmt_foreach(stmt_foreach& stm, scope& scp) -> void
         process_expr(stm.index, scp);
     }
 
-    process_stmt(stm.body.as_list->list[0], scp);
+    process_stmt(stm.body.as_comp->block->list[0], scp);
 
-    stm.body.as_list->list.erase(stm.body.as_list->list.begin());
+    stm.body.as_comp->block->list.erase(stm.body.as_comp->block->list.begin());
 
     scp.transfer_dec(scp_body);
 
     process_expr(stm.value, *scp_body);
     process_stmt(stm.body, *scp_body);
 
-    if (stm.body.as_list->list.size() == 1 && !stm.body.as_list->list[0].as_node->is_special_stmt())
+    if (stm.body.as_comp->block->list.size() == 1 && !stm.body.as_comp->block->list[0].as_node->is_special_stmt())
     {
-        stm.body = std::move(stm.body.as_list->list.back());
+        stm.body = std::move(stm.body.as_comp->block->list.back());
     }
 }
 
@@ -2776,11 +2800,10 @@ auto decompiler::process_stmt_switch(stmt_switch& stm, scope& scp) -> void
 
     process_expr(stm.test, scp);
 
-    for (auto& entry : stm.body->list)
+    for (auto& entry : stm.body->block->list)
     {
         if (entry == node::stmt_case)
         {
-            entry.as_case->body->is_case = true;
             auto scp_case = make_scope();
 
             scp.transfer_dec(scp_case);
@@ -2796,7 +2819,6 @@ auto decompiler::process_stmt_switch(stmt_switch& stm, scope& scp) -> void
         else if (entry == node::stmt_default)
         {
             has_default = true;
-            entry.as_default->body->is_case = true;
             auto scp_case = make_scope();
 
             scp.transfer_dec(scp_case);
diff --git a/src/gsc/decompiler.hpp b/src/gsc/decompiler.hpp
index b2397a1c..6e2aa8c9 100644
--- a/src/gsc/decompiler.hpp
+++ b/src/gsc/decompiler.hpp
@@ -52,6 +52,8 @@ private:
     auto process_function(decl_function& func) -> void;
     auto process_stmt(stmt& stm, scope& scp) -> void;
     auto process_stmt_list(stmt_list& stm, scope& scp) -> void;
+    auto process_stmt_comp(stmt_comp& stm, scope& scp) -> void;
+    auto process_stmt_dev(stmt_dev& stm, scope& scp) -> void;
     auto process_stmt_expr(stmt_expr& stm, scope& scp) -> void;
     auto process_stmt_call(stmt_call& stm, scope& scp) -> void;
     auto process_stmt_assign(stmt_assign& stm, scope& scp) -> void;
diff --git a/src/gsc/misc/ast.cpp b/src/gsc/misc/ast.cpp
index 3de96147..b411aa4c 100644
--- a/src/gsc/misc/ast.cpp
+++ b/src/gsc/misc/ast.cpp
@@ -414,7 +414,11 @@ stmt_list::stmt_list(location const& loc) : node{ type::stmt_list, loc }
 {
 }
 
-stmt_dev::stmt_dev(location const& loc, stmt_list::ptr body) : node{ type::stmt_dev, loc }, body{ std::move(body) }
+stmt_comp::stmt_comp(location const& loc, stmt_list::ptr block) : node{ type::stmt_comp, loc }, block{ std::move(block) }
+{
+}
+
+stmt_dev::stmt_dev(location const& loc, stmt_list::ptr block) : node{ type::stmt_dev, loc }, block{ std::move(block) }
 {
 }
 
@@ -482,7 +486,7 @@ stmt_foreach::stmt_foreach(location const& loc, expr container, expr value, expr
 {
 }
 
-stmt_switch::stmt_switch(location const& loc, expr test, stmt_list::ptr body) : node{ type::stmt_switch, loc }, test{ std::move(test) }, body{ std::move(body) }
+stmt_switch::stmt_switch(location const& loc, expr test, stmt_comp::ptr body) : node{ type::stmt_switch, loc }, test{ std::move(test) }, body{ std::move(body) }
 {
 }
 
@@ -526,7 +530,7 @@ stmt_prof_end::stmt_prof_end(location const& loc, expr_arguments::ptr args) : no
 {
 }
 
-decl_function::decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr body) : node{ type::decl_function, loc }, name{ std::move(name) }, params{ std::move(params) }, body{ std::move(body) }
+decl_function::decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_comp::ptr body) : node{ type::decl_function, loc }, name{ std::move(name) }, params{ std::move(params) }, body{ std::move(body) }
 {
 }
 
@@ -954,6 +958,7 @@ stmt::~stmt()
     {
         case node::null: as_node.~unique_ptr(); return;
         case node::stmt_list: as_list.~unique_ptr(); return;
+        case node::stmt_comp: as_comp.~unique_ptr(); return;
         case node::stmt_dev: as_dev.~unique_ptr(); return;
         case node::stmt_expr: as_expr.~unique_ptr(); return;
         case node::stmt_call: as_call.~unique_ptr(); return;
diff --git a/src/gsc/misc/ast.hpp b/src/gsc/misc/ast.hpp
index ab2daa39..976605fb 100644
--- a/src/gsc/misc/ast.hpp
+++ b/src/gsc/misc/ast.hpp
@@ -84,6 +84,7 @@ struct node
         expr_assign_bitwise_and,
         expr_assign_bitwise_exor,
         stmt_list,
+        stmt_comp,
         stmt_dev,
         stmt_expr,
         stmt_call,
@@ -228,6 +229,7 @@ struct expr_assign_bitwise_or;
 struct expr_assign_bitwise_and;
 struct expr_assign_bitwise_exor;
 struct stmt_list;
+struct stmt_comp;
 struct stmt_dev;
 struct stmt_expr;
 struct stmt_call;
@@ -390,6 +392,7 @@ union stmt
 {
     std::unique_ptr<node> as_node;
     std::unique_ptr<stmt_list> as_list;
+    std::unique_ptr<stmt_comp> as_comp;
     std::unique_ptr<stmt_dev> as_dev;
     std::unique_ptr<stmt_expr> as_expr;
     std::unique_ptr<stmt_call> as_call;
@@ -1058,19 +1061,26 @@ struct stmt_list : public node
     using ptr = std::unique_ptr<stmt_list>;
 
     std::vector<stmt> list;
-    bool is_case = false;
-    bool is_expr = false;
 
     stmt_list(location const& loc);
 };
 
+struct stmt_comp : public node
+{
+    using ptr = std::unique_ptr<stmt_comp>;
+
+    stmt_list::ptr block;
+
+    stmt_comp(location const& loc, stmt_list::ptr block);
+};
+
 struct stmt_dev : public node
 {
     using ptr = std::unique_ptr<stmt_dev>;
 
-    stmt_list::ptr body;
+    stmt_list::ptr block;
 
-    stmt_dev(location const& loc, stmt_list::ptr body);
+    stmt_dev(location const& loc, stmt_list::ptr block);
 };
 
 struct stmt_expr : public node
@@ -1239,9 +1249,9 @@ struct stmt_switch : public node
     using ptr = std::unique_ptr<stmt_switch>;
 
     expr test;
-    stmt_list::ptr body;
+    stmt_comp::ptr body;
 
-    stmt_switch(location const& loc, expr test, stmt_list::ptr body);
+    stmt_switch(location const& loc, expr test, stmt_comp::ptr body);
 };
 
 struct stmt_case : public node
@@ -1319,9 +1329,9 @@ struct decl_function : public node
 
     expr_identifier::ptr name;
     expr_parameters::ptr params;
-    stmt_list::ptr body;
+    stmt_comp::ptr body;
 
-    decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_list::ptr body);
+    decl_function(location const& loc, expr_identifier::ptr name, expr_parameters::ptr params, stmt_comp::ptr body);
 };
 
 struct decl_usingtree : public node
@@ -1562,6 +1572,7 @@ XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_or)
 XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_and)
 XSK_GSC_MAKE_GENERIC(expr_assign_bitwise_exor)
 XSK_GSC_MAKE_GENERIC(stmt_list)
+XSK_GSC_MAKE_GENERIC(stmt_comp)
 XSK_GSC_MAKE_GENERIC(stmt_dev)
 XSK_GSC_MAKE_GENERIC(stmt_expr)
 XSK_GSC_MAKE_GENERIC(stmt_call)
diff --git a/src/gsc/parser.cpp b/src/gsc/parser.cpp
index 82c9b86d..d9f0fa79 100644
--- a/src/gsc/parser.cpp
+++ b/src/gsc/parser.cpp
@@ -432,6 +432,10 @@ namespace xsk { namespace gsc {
         value.YY_MOVE_OR_COPY< stmt_case::ptr > (YY_MOVE (that.value));
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.YY_MOVE_OR_COPY< stmt_comp::ptr > (YY_MOVE (that.value));
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.YY_MOVE_OR_COPY< stmt_continue::ptr > (YY_MOVE (that.value));
         break;
@@ -474,7 +478,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.YY_MOVE_OR_COPY< stmt_list::ptr > (YY_MOVE (that.value));
         break;
 
@@ -748,6 +751,10 @@ namespace xsk { namespace gsc {
         value.move< stmt_case::ptr > (YY_MOVE (that.value));
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.move< stmt_comp::ptr > (YY_MOVE (that.value));
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.move< stmt_continue::ptr > (YY_MOVE (that.value));
         break;
@@ -790,7 +797,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.move< stmt_list::ptr > (YY_MOVE (that.value));
         break;
 
@@ -1064,6 +1070,10 @@ namespace xsk { namespace gsc {
         value.copy< stmt_case::ptr > (that.value);
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.copy< stmt_comp::ptr > (that.value);
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.copy< stmt_continue::ptr > (that.value);
         break;
@@ -1106,7 +1116,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.copy< stmt_list::ptr > (that.value);
         break;
 
@@ -1379,6 +1388,10 @@ namespace xsk { namespace gsc {
         value.move< stmt_case::ptr > (that.value);
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.move< stmt_comp::ptr > (that.value);
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.move< stmt_continue::ptr > (that.value);
         break;
@@ -1421,7 +1434,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.move< stmt_list::ptr > (that.value);
         break;
 
@@ -1949,6 +1961,10 @@ namespace xsk { namespace gsc {
         yylhs.value.emplace< stmt_case::ptr > ();
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        yylhs.value.emplace< stmt_comp::ptr > ();
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         yylhs.value.emplace< stmt_continue::ptr > ();
         break;
@@ -1991,7 +2007,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         yylhs.value.emplace< stmt_list::ptr > ();
         break;
 
@@ -2062,457 +2077,457 @@ namespace xsk { namespace gsc {
   case 2: // root: program
 #line 272 "parser.ypp"
               { ast = std::move(yystack_[0].value.as < program::ptr > ()); }
-#line 2066 "parser.cpp"
+#line 2081 "parser.cpp"
     break;
 
   case 3: // root: %empty
 #line 273 "parser.ypp"
               { ast = make_program(yylhs.location); }
-#line 2072 "parser.cpp"
+#line 2087 "parser.cpp"
     break;
 
   case 4: // program: program inline
 #line 278 "parser.ypp"
         { yylhs.value.as < program::ptr > () = std::move(yystack_[1].value.as < program::ptr > ()); }
-#line 2078 "parser.cpp"
+#line 2093 "parser.cpp"
     break;
 
   case 5: // program: program include
 #line 280 "parser.ypp"
         { yylhs.value.as < program::ptr > () = std::move(yystack_[1].value.as < program::ptr > ()); yylhs.value.as < program::ptr > ()->includes.push_back(std::move(yystack_[0].value.as < include::ptr > ())); }
-#line 2084 "parser.cpp"
+#line 2099 "parser.cpp"
     break;
 
   case 6: // program: program declaration
 #line 282 "parser.ypp"
         { yylhs.value.as < program::ptr > () = std::move(yystack_[1].value.as < program::ptr > ()); yylhs.value.as < program::ptr > ()->declarations.push_back(std::move(yystack_[0].value.as < decl > ())); }
-#line 2090 "parser.cpp"
+#line 2105 "parser.cpp"
     break;
 
   case 7: // program: inline
 #line 284 "parser.ypp"
         { yylhs.value.as < program::ptr > () = make_program(yylhs.location); }
-#line 2096 "parser.cpp"
+#line 2111 "parser.cpp"
     break;
 
   case 8: // program: include
 #line 286 "parser.ypp"
         { yylhs.value.as < program::ptr > () = make_program(yylhs.location); yylhs.value.as < program::ptr > ()->includes.push_back(std::move(yystack_[0].value.as < include::ptr > ())); }
-#line 2102 "parser.cpp"
+#line 2117 "parser.cpp"
     break;
 
   case 9: // program: declaration
 #line 288 "parser.ypp"
         { yylhs.value.as < program::ptr > () = make_program(yylhs.location); yylhs.value.as < program::ptr > ()->declarations.push_back(std::move(yystack_[0].value.as < decl > ())); }
-#line 2108 "parser.cpp"
+#line 2123 "parser.cpp"
     break;
 
   case 10: // inline: "#inline" expr_path ";"
 #line 292 "parser.ypp"
                                  { lexer.push_header(yystack_[1].value.as < expr_path::ptr > ()->value); }
-#line 2114 "parser.cpp"
+#line 2129 "parser.cpp"
     break;
 
   case 11: // include: "#include" expr_path ";"
 #line 297 "parser.ypp"
         { yylhs.value.as < include::ptr > () = make_include(yylhs.location, std::move(yystack_[1].value.as < expr_path::ptr > ())); }
-#line 2120 "parser.cpp"
+#line 2135 "parser.cpp"
     break;
 
   case 12: // declaration: "/#"
 #line 301 "parser.ypp"
                         { yylhs.value.as < decl > ().as_dev_begin = make_decl_dev_begin(yylhs.location); }
-#line 2126 "parser.cpp"
+#line 2141 "parser.cpp"
     break;
 
   case 13: // declaration: "#/"
 #line 302 "parser.ypp"
                         { yylhs.value.as < decl > ().as_dev_end = make_decl_dev_end(yylhs.location); }
-#line 2132 "parser.cpp"
+#line 2147 "parser.cpp"
     break;
 
   case 14: // declaration: decl_usingtree
 #line 303 "parser.ypp"
                         { yylhs.value.as < decl > ().as_usingtree = std::move(yystack_[0].value.as < decl_usingtree::ptr > ()); }
-#line 2138 "parser.cpp"
+#line 2153 "parser.cpp"
     break;
 
   case 15: // declaration: decl_function
 #line 304 "parser.ypp"
                         { yylhs.value.as < decl > ().as_function = std::move(yystack_[0].value.as < decl_function::ptr > ()); }
-#line 2144 "parser.cpp"
+#line 2159 "parser.cpp"
     break;
 
   case 16: // decl_usingtree: "#using_animtree" "(" expr_string ")" ";"
 #line 309 "parser.ypp"
         { lexer.ban_header(yylhs.location); yylhs.value.as < decl_usingtree::ptr > () = make_decl_usingtree(yylhs.location, std::move(yystack_[2].value.as < expr_string::ptr > ())); }
-#line 2150 "parser.cpp"
+#line 2165 "parser.cpp"
     break;
 
-  case 17: // decl_function: expr_identifier "(" expr_parameters ")" stmt_block
+  case 17: // decl_function: expr_identifier "(" expr_parameters ")" stmt_comp
 #line 314 "parser.ypp"
-        { lexer.ban_header(yylhs.location); yylhs.value.as < decl_function::ptr > () = make_decl_function(yylhs.location, std::move(yystack_[4].value.as < expr_identifier::ptr > ()), std::move(yystack_[2].value.as < expr_parameters::ptr > ()), std::move(yystack_[0].value.as < stmt_list::ptr > ())); }
-#line 2156 "parser.cpp"
+        { lexer.ban_header(yylhs.location); yylhs.value.as < decl_function::ptr > () = make_decl_function(yylhs.location, std::move(yystack_[4].value.as < expr_identifier::ptr > ()), std::move(yystack_[2].value.as < expr_parameters::ptr > ()), std::move(yystack_[0].value.as < stmt_comp::ptr > ())); }
+#line 2171 "parser.cpp"
     break;
 
-  case 18: // stmt: stmt_block
+  case 18: // stmt: stmt_comp
 #line 318 "parser.ypp"
-                             { yylhs.value.as < stmt > ().as_list = std::move(yystack_[0].value.as < stmt_list::ptr > ()); }
-#line 2162 "parser.cpp"
+                             { yylhs.value.as < stmt > ().as_comp = std::move(yystack_[0].value.as < stmt_comp::ptr > ()); }
+#line 2177 "parser.cpp"
     break;
 
   case 19: // stmt: stmt_call
 #line 319 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_call = std::move(yystack_[0].value.as < stmt_call::ptr > ()); }
-#line 2168 "parser.cpp"
+#line 2183 "parser.cpp"
     break;
 
   case 20: // stmt: stmt_assign
 #line 320 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_assign = std::move(yystack_[0].value.as < stmt_assign::ptr > ()); }
-#line 2174 "parser.cpp"
+#line 2189 "parser.cpp"
     break;
 
   case 21: // stmt: stmt_endon
 #line 321 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_endon = std::move(yystack_[0].value.as < stmt_endon::ptr > ()); }
-#line 2180 "parser.cpp"
+#line 2195 "parser.cpp"
     break;
 
   case 22: // stmt: stmt_notify
 #line 322 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_notify = std::move(yystack_[0].value.as < stmt_notify::ptr > ()); }
-#line 2186 "parser.cpp"
+#line 2201 "parser.cpp"
     break;
 
   case 23: // stmt: stmt_wait
 #line 323 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_wait = std::move(yystack_[0].value.as < stmt_wait::ptr > ()); }
-#line 2192 "parser.cpp"
+#line 2207 "parser.cpp"
     break;
 
   case 24: // stmt: stmt_waittill
 #line 324 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_waittill = std::move(yystack_[0].value.as < stmt_waittill::ptr > ()); }
-#line 2198 "parser.cpp"
+#line 2213 "parser.cpp"
     break;
 
   case 25: // stmt: stmt_waittillmatch
 #line 325 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_waittillmatch = std::move(yystack_[0].value.as < stmt_waittillmatch::ptr > ()); }
-#line 2204 "parser.cpp"
+#line 2219 "parser.cpp"
     break;
 
   case 26: // stmt: stmt_waittillframeend
 #line 326 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_waittillframeend = std::move(yystack_[0].value.as < stmt_waittillframeend::ptr > ()); }
-#line 2210 "parser.cpp"
+#line 2225 "parser.cpp"
     break;
 
   case 27: // stmt: stmt_waitframe
 #line 327 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_waitframe = std::move(yystack_[0].value.as < stmt_waitframe::ptr > ()); }
-#line 2216 "parser.cpp"
+#line 2231 "parser.cpp"
     break;
 
   case 28: // stmt: stmt_if
 #line 328 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_if = std::move(yystack_[0].value.as < stmt_if::ptr > ()); }
-#line 2222 "parser.cpp"
+#line 2237 "parser.cpp"
     break;
 
   case 29: // stmt: stmt_ifelse
 #line 329 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_ifelse = std::move(yystack_[0].value.as < stmt_ifelse::ptr > ()); }
-#line 2228 "parser.cpp"
+#line 2243 "parser.cpp"
     break;
 
   case 30: // stmt: stmt_while
 #line 330 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_while = std::move(yystack_[0].value.as < stmt_while::ptr > ()); }
-#line 2234 "parser.cpp"
+#line 2249 "parser.cpp"
     break;
 
   case 31: // stmt: stmt_dowhile
 #line 331 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_dowhile = std::move(yystack_[0].value.as < stmt_dowhile::ptr > ()); }
-#line 2240 "parser.cpp"
+#line 2255 "parser.cpp"
     break;
 
   case 32: // stmt: stmt_for
 #line 332 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_for = std::move(yystack_[0].value.as < stmt_for::ptr > ()); }
-#line 2246 "parser.cpp"
+#line 2261 "parser.cpp"
     break;
 
   case 33: // stmt: stmt_foreach
 #line 333 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_foreach = std::move(yystack_[0].value.as < stmt_foreach::ptr > ()); }
-#line 2252 "parser.cpp"
+#line 2267 "parser.cpp"
     break;
 
   case 34: // stmt: stmt_switch
 #line 334 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_switch = std::move(yystack_[0].value.as < stmt_switch::ptr > ()); }
-#line 2258 "parser.cpp"
+#line 2273 "parser.cpp"
     break;
 
   case 35: // stmt: stmt_case
 #line 335 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_case = std::move(yystack_[0].value.as < stmt_case::ptr > ()); }
-#line 2264 "parser.cpp"
+#line 2279 "parser.cpp"
     break;
 
   case 36: // stmt: stmt_default
 #line 336 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_default = std::move(yystack_[0].value.as < stmt_default::ptr > ()); }
-#line 2270 "parser.cpp"
+#line 2285 "parser.cpp"
     break;
 
   case 37: // stmt: stmt_break
 #line 337 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_break = std::move(yystack_[0].value.as < stmt_break::ptr > ()); }
-#line 2276 "parser.cpp"
+#line 2291 "parser.cpp"
     break;
 
   case 38: // stmt: stmt_continue
 #line 338 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_continue = std::move(yystack_[0].value.as < stmt_continue::ptr > ()); }
-#line 2282 "parser.cpp"
+#line 2297 "parser.cpp"
     break;
 
   case 39: // stmt: stmt_return
 #line 339 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_return = std::move(yystack_[0].value.as < stmt_return::ptr > ()); }
-#line 2288 "parser.cpp"
+#line 2303 "parser.cpp"
     break;
 
   case 40: // stmt: stmt_breakpoint
 #line 340 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_breakpoint = std::move(yystack_[0].value.as < stmt_breakpoint::ptr > ()); }
-#line 2294 "parser.cpp"
+#line 2309 "parser.cpp"
     break;
 
   case 41: // stmt: stmt_prof_begin
 #line 341 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_prof_begin = std::move(yystack_[0].value.as < stmt_prof_begin::ptr > ()); }
-#line 2300 "parser.cpp"
+#line 2315 "parser.cpp"
     break;
 
   case 42: // stmt: stmt_prof_end
 #line 342 "parser.ypp"
                              { yylhs.value.as < stmt > ().as_prof_end = std::move(yystack_[0].value.as < stmt_prof_end::ptr > ()); }
-#line 2306 "parser.cpp"
+#line 2321 "parser.cpp"
     break;
 
   case 43: // stmt_or_dev: stmt
 #line 346 "parser.ypp"
                { yylhs.value.as < stmt > () = std::move(yystack_[0].value.as < stmt > ()); }
-#line 2312 "parser.cpp"
+#line 2327 "parser.cpp"
     break;
 
   case 44: // stmt_or_dev: stmt_dev
 #line 347 "parser.ypp"
                { yylhs.value.as < stmt > ().as_dev = std::move(yystack_[0].value.as < stmt_dev::ptr > ()); }
-#line 2318 "parser.cpp"
+#line 2333 "parser.cpp"
     break;
 
   case 45: // stmt_list: stmt_list stmt
 #line 352 "parser.ypp"
         { yylhs.value.as < stmt_list::ptr > () = std::move(yystack_[1].value.as < stmt_list::ptr > ()); yylhs.value.as < stmt_list::ptr > ()->list.push_back(std::move(yystack_[0].value.as < stmt > ())); }
-#line 2324 "parser.cpp"
+#line 2339 "parser.cpp"
     break;
 
   case 46: // stmt_list: stmt
 #line 354 "parser.ypp"
         { yylhs.value.as < stmt_list::ptr > () = make_stmt_list(yylhs.location); yylhs.value.as < stmt_list::ptr > ()->list.push_back(std::move(yystack_[0].value.as < stmt > ())); }
-#line 2330 "parser.cpp"
+#line 2345 "parser.cpp"
     break;
 
   case 47: // stmt_or_dev_list: stmt_or_dev_list stmt_or_dev
 #line 359 "parser.ypp"
         { yylhs.value.as < stmt_list::ptr > () = std::move(yystack_[1].value.as < stmt_list::ptr > ()); yylhs.value.as < stmt_list::ptr > ()->list.push_back(std::move(yystack_[0].value.as < stmt > ())); }
-#line 2336 "parser.cpp"
+#line 2351 "parser.cpp"
     break;
 
   case 48: // stmt_or_dev_list: stmt_or_dev
 #line 361 "parser.ypp"
         { yylhs.value.as < stmt_list::ptr > () = make_stmt_list(yylhs.location); yylhs.value.as < stmt_list::ptr > ()->list.push_back(std::move(yystack_[0].value.as < stmt > ())); }
-#line 2342 "parser.cpp"
+#line 2357 "parser.cpp"
     break;
 
   case 49: // stmt_dev: "/#" stmt_list "#/"
 #line 365 "parser.ypp"
                                 { yylhs.value.as < stmt_dev::ptr > () = make_stmt_dev(yylhs.location, std::move(yystack_[1].value.as < stmt_list::ptr > ())); }
-#line 2348 "parser.cpp"
+#line 2363 "parser.cpp"
     break;
 
   case 50: // stmt_dev: "/#" "#/"
 #line 366 "parser.ypp"
                       { yylhs.value.as < stmt_dev::ptr > () = make_stmt_dev(yylhs.location, make_stmt_list(yylhs.location)); }
-#line 2354 "parser.cpp"
+#line 2369 "parser.cpp"
     break;
 
-  case 51: // stmt_block: "{" stmt_or_dev_list "}"
+  case 51: // stmt_comp: "{" stmt_or_dev_list "}"
 #line 370 "parser.ypp"
-                                     { yylhs.value.as < stmt_list::ptr > () = std::move(yystack_[1].value.as < stmt_list::ptr > ()); }
-#line 2360 "parser.cpp"
+                                     { yylhs.value.as < stmt_comp::ptr > () = make_stmt_comp(yylhs.location, std::move(yystack_[1].value.as < stmt_list::ptr > ())); }
+#line 2375 "parser.cpp"
     break;
 
-  case 52: // stmt_block: "{" "}"
+  case 52: // stmt_comp: "{" "}"
 #line 371 "parser.ypp"
-                    { yylhs.value.as < stmt_list::ptr > () = make_stmt_list(yylhs.location); }
-#line 2366 "parser.cpp"
+                    { yylhs.value.as < stmt_comp::ptr > () = make_stmt_comp(yylhs.location, make_stmt_list(yylhs.location)); }
+#line 2381 "parser.cpp"
     break;
 
   case 53: // stmt_expr: expr_assign
 #line 376 "parser.ypp"
         { yylhs.value.as < stmt_expr::ptr > () = make_stmt_expr(yylhs.location, std::move(yystack_[0].value.as < expr > ())); }
-#line 2372 "parser.cpp"
+#line 2387 "parser.cpp"
     break;
 
   case 54: // stmt_expr: expr_increment
 #line 378 "parser.ypp"
         { yylhs.value.as < stmt_expr::ptr > () = make_stmt_expr(yylhs.location, std::move(yystack_[0].value.as < expr > ())); }
-#line 2378 "parser.cpp"
+#line 2393 "parser.cpp"
     break;
 
   case 55: // stmt_expr: expr_decrement
 #line 380 "parser.ypp"
         { yylhs.value.as < stmt_expr::ptr > () = make_stmt_expr(yylhs.location, std::move(yystack_[0].value.as < expr > ())); }
-#line 2384 "parser.cpp"
+#line 2399 "parser.cpp"
     break;
 
   case 56: // stmt_expr: %empty
 #line 382 "parser.ypp"
         { yylhs.value.as < stmt_expr::ptr > () = make_stmt_expr(yylhs.location, make_node(yylhs.location)); }
-#line 2390 "parser.cpp"
+#line 2405 "parser.cpp"
     break;
 
   case 57: // stmt_call: expr_call ";"
 #line 387 "parser.ypp"
         { yylhs.value.as < stmt_call::ptr > () = make_stmt_call(yylhs.location, expr{ std::move(yystack_[1].value.as < expr_call::ptr > ()) }); }
-#line 2396 "parser.cpp"
+#line 2411 "parser.cpp"
     break;
 
   case 58: // stmt_call: expr_method ";"
 #line 389 "parser.ypp"
         { yylhs.value.as < stmt_call::ptr > () = make_stmt_call(yylhs.location, expr{ std::move(yystack_[1].value.as < expr_method::ptr > ()) }); }
-#line 2402 "parser.cpp"
+#line 2417 "parser.cpp"
     break;
 
   case 59: // stmt_assign: expr_assign ";"
 #line 394 "parser.ypp"
         { yylhs.value.as < stmt_assign::ptr > () = make_stmt_assign(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 2408 "parser.cpp"
+#line 2423 "parser.cpp"
     break;
 
   case 60: // stmt_assign: expr_increment ";"
 #line 396 "parser.ypp"
         { yylhs.value.as < stmt_assign::ptr > () = make_stmt_assign(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 2414 "parser.cpp"
+#line 2429 "parser.cpp"
     break;
 
   case 61: // stmt_assign: expr_decrement ";"
 #line 398 "parser.ypp"
         { yylhs.value.as < stmt_assign::ptr > () = make_stmt_assign(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 2420 "parser.cpp"
+#line 2435 "parser.cpp"
     break;
 
   case 62: // stmt_endon: expr_object "endon" "(" expr ")" ";"
 #line 403 "parser.ypp"
         { yylhs.value.as < stmt_endon::ptr > () = make_stmt_endon(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[2].value.as < expr > ())); }
-#line 2426 "parser.cpp"
+#line 2441 "parser.cpp"
     break;
 
   case 63: // stmt_notify: expr_object "notify" "(" expr "," expr_arguments_no_empty ")" ";"
 #line 408 "parser.ypp"
         { yylhs.value.as < stmt_notify::ptr > () = make_stmt_notify(yylhs.location, std::move(yystack_[7].value.as < expr > ()), std::move(yystack_[4].value.as < expr > ()), std::move(yystack_[2].value.as < expr_arguments::ptr > ())); }
-#line 2432 "parser.cpp"
+#line 2447 "parser.cpp"
     break;
 
   case 64: // stmt_notify: expr_object "notify" "(" expr ")" ";"
 #line 410 "parser.ypp"
         { yylhs.value.as < stmt_notify::ptr > () = make_stmt_notify(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[2].value.as < expr > ()), make_expr_arguments(yylhs.location)); }
-#line 2438 "parser.cpp"
+#line 2453 "parser.cpp"
     break;
 
   case 65: // stmt_wait: "wait" expr ";"
 #line 415 "parser.ypp"
         { yylhs.value.as < stmt_wait::ptr > () = make_stmt_wait(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 2444 "parser.cpp"
+#line 2459 "parser.cpp"
     break;
 
   case 66: // stmt_waittill: expr_object "waittill" "(" expr "," expr_arguments_no_empty ")" ";"
 #line 420 "parser.ypp"
         { yylhs.value.as < stmt_waittill::ptr > () = make_stmt_waittill(yylhs.location, std::move(yystack_[7].value.as < expr > ()), std::move(yystack_[4].value.as < expr > ()), std::move(yystack_[2].value.as < expr_arguments::ptr > ())); }
-#line 2450 "parser.cpp"
+#line 2465 "parser.cpp"
     break;
 
   case 67: // stmt_waittill: expr_object "waittill" "(" expr ")" ";"
 #line 422 "parser.ypp"
         { yylhs.value.as < stmt_waittill::ptr > () = make_stmt_waittill(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[2].value.as < expr > ()), make_expr_arguments(yylhs.location)); }
-#line 2456 "parser.cpp"
+#line 2471 "parser.cpp"
     break;
 
   case 68: // stmt_waittillmatch: expr_object "waittillmatch" "(" expr "," expr_arguments_no_empty ")" ";"
 #line 427 "parser.ypp"
         { yylhs.value.as < stmt_waittillmatch::ptr > () = make_stmt_waittillmatch(yylhs.location, std::move(yystack_[7].value.as < expr > ()), std::move(yystack_[4].value.as < expr > ()), std::move(yystack_[2].value.as < expr_arguments::ptr > ())); }
-#line 2462 "parser.cpp"
+#line 2477 "parser.cpp"
     break;
 
   case 69: // stmt_waittillmatch: expr_object "waittillmatch" "(" expr ")" ";"
 #line 429 "parser.ypp"
         { yylhs.value.as < stmt_waittillmatch::ptr > () = make_stmt_waittillmatch(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[2].value.as < expr > ()), make_expr_arguments(yylhs.location)); }
-#line 2468 "parser.cpp"
+#line 2483 "parser.cpp"
     break;
 
   case 70: // stmt_waittillframeend: "waittillframeend" ";"
 #line 434 "parser.ypp"
         { yylhs.value.as < stmt_waittillframeend::ptr > () = make_stmt_waittillframeend(yylhs.location); }
-#line 2474 "parser.cpp"
+#line 2489 "parser.cpp"
     break;
 
   case 71: // stmt_waitframe: "waitframe" ";"
 #line 439 "parser.ypp"
         { yylhs.value.as < stmt_waitframe::ptr > () = make_stmt_waitframe(yylhs.location); }
-#line 2480 "parser.cpp"
+#line 2495 "parser.cpp"
     break;
 
   case 72: // stmt_waitframe: "waitframe" "(" ")" ";"
 #line 441 "parser.ypp"
         { yylhs.value.as < stmt_waitframe::ptr > () = make_stmt_waitframe(yylhs.location); }
-#line 2486 "parser.cpp"
+#line 2501 "parser.cpp"
     break;
 
   case 73: // stmt_if: "if" "(" expr ")" stmt
 #line 446 "parser.ypp"
         { yylhs.value.as < stmt_if::ptr > () = make_stmt_if(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < stmt > ())); }
-#line 2492 "parser.cpp"
+#line 2507 "parser.cpp"
     break;
 
   case 74: // stmt_ifelse: "if" "(" expr ")" stmt "else" stmt
 #line 451 "parser.ypp"
         { yylhs.value.as < stmt_ifelse::ptr > () = make_stmt_ifelse(yylhs.location, std::move(yystack_[4].value.as < expr > ()), std::move(yystack_[2].value.as < stmt > ()), std::move(yystack_[0].value.as < stmt > ())); }
-#line 2498 "parser.cpp"
+#line 2513 "parser.cpp"
     break;
 
   case 75: // stmt_while: "while" "(" expr ")" stmt
 #line 456 "parser.ypp"
         { yylhs.value.as < stmt_while::ptr > () = make_stmt_while(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < stmt > ())); }
-#line 2504 "parser.cpp"
+#line 2519 "parser.cpp"
     break;
 
   case 76: // stmt_dowhile: "do" stmt "while" "(" expr ")" ";"
 #line 461 "parser.ypp"
         { yylhs.value.as < stmt_dowhile::ptr > () = make_stmt_dowhile(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[5].value.as < stmt > ())); }
-#line 2510 "parser.cpp"
+#line 2525 "parser.cpp"
     break;
 
   case 77: // stmt_for: "for" "(" stmt_expr ";" expr_or_empty ";" stmt_expr ")" stmt
 #line 466 "parser.ypp"
         { yylhs.value.as < stmt_for::ptr > () = make_stmt_for(yylhs.location, stmt{ std::move(yystack_[6].value.as < stmt_expr::ptr > ()) }, std::move(yystack_[4].value.as < expr > ()), stmt{ std::move(yystack_[2].value.as < stmt_expr::ptr > ()) }, std::move(yystack_[0].value.as < stmt > ())); }
-#line 2516 "parser.cpp"
+#line 2531 "parser.cpp"
     break;
 
   case 78: // stmt_foreach: "foreach" "(" expr_identifier "in" expr ")" stmt
@@ -2521,7 +2536,7 @@ namespace xsk { namespace gsc {
             auto array = expr{ make_expr_identifier(yylhs.location, fmt::format("_temp_{}", ++index)) };
             auto key = expr{ make_expr_identifier(yylhs.location, fmt::format("_temp_{}", ++index)) };
             yylhs.value.as < stmt_foreach::ptr > () = make_stmt_foreach(yylhs.location, std::move(yystack_[2].value.as < expr > ()), expr{ std::move(yystack_[4].value.as < expr_identifier::ptr > ()) }, expr{ make_node(yylhs.location) }, std::move(array), std::move(key), std::move(yystack_[0].value.as < stmt > ()), false); }
-#line 2525 "parser.cpp"
+#line 2540 "parser.cpp"
     break;
 
   case 79: // stmt_foreach: "foreach" "(" expr_identifier "," expr_identifier "in" expr ")" stmt
@@ -2531,687 +2546,687 @@ namespace xsk { namespace gsc {
             auto key = (ctx_->props() & props::foreach) ? expr{ make_expr_identifier(yylhs.location, fmt::format("_temp_{}", ++index)) } : expr{ std::move(yystack_[6].value.as < expr_identifier::ptr > ()) };
             yylhs.value.as < stmt_foreach::ptr > () = make_stmt_foreach(yylhs.location, std::move(yystack_[2].value.as < expr > ()), expr{ std::move(yystack_[4].value.as < expr_identifier::ptr > ()) }, (ctx_->props() & props::foreach) ? expr{ std::move(yystack_[6].value.as < expr_identifier::ptr > ()) } : expr{ make_node(yylhs.location) }, std::move(array), std::move(key), std::move(yystack_[0].value.as < stmt > ()), true);
         }
-#line 2535 "parser.cpp"
+#line 2550 "parser.cpp"
     break;
 
-  case 80: // stmt_switch: "switch" "(" expr ")" stmt_block
+  case 80: // stmt_switch: "switch" "(" expr ")" stmt_comp
 #line 485 "parser.ypp"
-        { yylhs.value.as < stmt_switch::ptr > () = make_stmt_switch(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < stmt_list::ptr > ())); 
+        { yylhs.value.as < stmt_switch::ptr > () = make_stmt_switch(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < stmt_comp::ptr > ())); 
           parse_switch(*yylhs.value.as < stmt_switch::ptr > ());
         }
-#line 2543 "parser.cpp"
+#line 2558 "parser.cpp"
     break;
 
   case 81: // stmt_case: "case" expr_integer ":"
 #line 492 "parser.ypp"
         { yylhs.value.as < stmt_case::ptr > () = make_stmt_case(yylhs.location, expr{ std::move(yystack_[1].value.as < expr_integer::ptr > ()) }, make_stmt_list(yylhs.location)); }
-#line 2549 "parser.cpp"
+#line 2564 "parser.cpp"
     break;
 
   case 82: // stmt_case: "case" expr_string ":"
 #line 494 "parser.ypp"
         { yylhs.value.as < stmt_case::ptr > () = make_stmt_case(yylhs.location, expr{ std::move(yystack_[1].value.as < expr_string::ptr > ()) }, make_stmt_list(yylhs.location)); }
-#line 2555 "parser.cpp"
+#line 2570 "parser.cpp"
     break;
 
   case 83: // stmt_default: "default" ":"
 #line 499 "parser.ypp"
         { yylhs.value.as < stmt_default::ptr > () = make_stmt_default(yylhs.location, make_stmt_list(yylhs.location)); }
-#line 2561 "parser.cpp"
+#line 2576 "parser.cpp"
     break;
 
   case 84: // stmt_break: "break" ";"
 #line 504 "parser.ypp"
         { yylhs.value.as < stmt_break::ptr > () = make_stmt_break(yylhs.location); }
-#line 2567 "parser.cpp"
+#line 2582 "parser.cpp"
     break;
 
   case 85: // stmt_continue: "continue" ";"
 #line 509 "parser.ypp"
         { yylhs.value.as < stmt_continue::ptr > () = make_stmt_continue(yylhs.location); }
-#line 2573 "parser.cpp"
+#line 2588 "parser.cpp"
     break;
 
   case 86: // stmt_return: "return" expr ";"
 #line 514 "parser.ypp"
         { yylhs.value.as < stmt_return::ptr > () = make_stmt_return(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 2579 "parser.cpp"
+#line 2594 "parser.cpp"
     break;
 
   case 87: // stmt_return: "return" ";"
 #line 516 "parser.ypp"
         { yylhs.value.as < stmt_return::ptr > () = make_stmt_return(yylhs.location, make_node(yylhs.location)); }
-#line 2585 "parser.cpp"
+#line 2600 "parser.cpp"
     break;
 
   case 88: // stmt_breakpoint: "breakpoint" ";"
 #line 521 "parser.ypp"
         { yylhs.value.as < stmt_breakpoint::ptr > () = make_stmt_breakpoint(yylhs.location); }
-#line 2591 "parser.cpp"
+#line 2606 "parser.cpp"
     break;
 
   case 89: // stmt_prof_begin: "prof_begin" "(" expr_arguments ")" ";"
 #line 526 "parser.ypp"
         { yylhs.value.as < stmt_prof_begin::ptr > () = make_stmt_prof_begin(yylhs.location, std::move(yystack_[2].value.as < expr_arguments::ptr > ())); }
-#line 2597 "parser.cpp"
+#line 2612 "parser.cpp"
     break;
 
   case 90: // stmt_prof_end: "prof_end" "(" expr_arguments ")" ";"
 #line 531 "parser.ypp"
         { yylhs.value.as < stmt_prof_end::ptr > () = make_stmt_prof_end(yylhs.location, std::move(yystack_[2].value.as < expr_arguments::ptr > ())); }
-#line 2603 "parser.cpp"
+#line 2618 "parser.cpp"
     break;
 
   case 91: // expr: expr_ternary
 #line 535 "parser.ypp"
                      { yylhs.value.as < expr > () = std::move(yystack_[0].value.as < expr > ()); }
-#line 2609 "parser.cpp"
+#line 2624 "parser.cpp"
     break;
 
   case 92: // expr: expr_binary
 #line 536 "parser.ypp"
                      { yylhs.value.as < expr > () = std::move(yystack_[0].value.as < expr > ()); }
-#line 2615 "parser.cpp"
+#line 2630 "parser.cpp"
     break;
 
   case 93: // expr: expr_primitive
 #line 537 "parser.ypp"
                      { yylhs.value.as < expr > () = std::move(yystack_[0].value.as < expr > ()); }
-#line 2621 "parser.cpp"
+#line 2636 "parser.cpp"
     break;
 
   case 94: // expr_or_empty: expr
 #line 541 "parser.ypp"
                      { yylhs.value.as < expr > () = std::move(yystack_[0].value.as < expr > ()); }
-#line 2627 "parser.cpp"
+#line 2642 "parser.cpp"
     break;
 
   case 95: // expr_or_empty: %empty
 #line 542 "parser.ypp"
                      { yylhs.value.as < expr > ().as_node = make_node(yylhs.location); }
-#line 2633 "parser.cpp"
+#line 2648 "parser.cpp"
     break;
 
   case 96: // expr_assign: expr_tuple "=" expr
 #line 547 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_equal(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2639 "parser.cpp"
+#line 2654 "parser.cpp"
     break;
 
   case 97: // expr_assign: expr_object "=" expr
 #line 549 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_equal(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2645 "parser.cpp"
+#line 2660 "parser.cpp"
     break;
 
   case 98: // expr_assign: expr_object "|=" expr
 #line 551 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_bitwise_or(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2651 "parser.cpp"
+#line 2666 "parser.cpp"
     break;
 
   case 99: // expr_assign: expr_object "&=" expr
 #line 553 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_bitwise_and(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2657 "parser.cpp"
+#line 2672 "parser.cpp"
     break;
 
   case 100: // expr_assign: expr_object "^=" expr
 #line 555 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_bitwise_exor(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2663 "parser.cpp"
+#line 2678 "parser.cpp"
     break;
 
   case 101: // expr_assign: expr_object "<<=" expr
 #line 557 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_shift_left(yylhs.location, std::move(yystack_[2].value.as < expr > ()),std::move( yystack_[0].value.as < expr > ())); }
-#line 2669 "parser.cpp"
+#line 2684 "parser.cpp"
     break;
 
   case 102: // expr_assign: expr_object ">>=" expr
 #line 559 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_shift_right(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2675 "parser.cpp"
+#line 2690 "parser.cpp"
     break;
 
   case 103: // expr_assign: expr_object "+=" expr
 #line 561 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_add(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2681 "parser.cpp"
+#line 2696 "parser.cpp"
     break;
 
   case 104: // expr_assign: expr_object "-=" expr
 #line 563 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_sub(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2687 "parser.cpp"
+#line 2702 "parser.cpp"
     break;
 
   case 105: // expr_assign: expr_object "*=" expr
 #line 565 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_mul(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2693 "parser.cpp"
+#line 2708 "parser.cpp"
     break;
 
   case 106: // expr_assign: expr_object "/=" expr
 #line 567 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_div(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2699 "parser.cpp"
+#line 2714 "parser.cpp"
     break;
 
   case 107: // expr_assign: expr_object "%=" expr
 #line 569 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_assign_mod(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2705 "parser.cpp"
+#line 2720 "parser.cpp"
     break;
 
   case 108: // expr_increment: "++" expr_object
 #line 574 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_increment(yylhs.location, std::move(yystack_[0].value.as < expr > ()), true); }
-#line 2711 "parser.cpp"
+#line 2726 "parser.cpp"
     break;
 
   case 109: // expr_increment: expr_object "++"
 #line 576 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_increment(yylhs.location, std::move(yystack_[1].value.as < expr > ()), false); }
-#line 2717 "parser.cpp"
+#line 2732 "parser.cpp"
     break;
 
   case 110: // expr_decrement: "--" expr_object
 #line 581 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_decrement(yylhs.location, std::move(yystack_[0].value.as < expr > ()), true); }
-#line 2723 "parser.cpp"
+#line 2738 "parser.cpp"
     break;
 
   case 111: // expr_decrement: expr_object "--"
 #line 583 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_decrement(yylhs.location, std::move(yystack_[1].value.as < expr > ()), false); }
-#line 2729 "parser.cpp"
+#line 2744 "parser.cpp"
     break;
 
   case 112: // expr_ternary: expr "?" expr ":" expr
 #line 588 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_ternary(yylhs.location, std::move(yystack_[4].value.as < expr > ()), std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2735 "parser.cpp"
+#line 2750 "parser.cpp"
     break;
 
   case 113: // expr_binary: expr "||" expr
 #line 593 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_or(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2741 "parser.cpp"
+#line 2756 "parser.cpp"
     break;
 
   case 114: // expr_binary: expr "&&" expr
 #line 595 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_and(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2747 "parser.cpp"
+#line 2762 "parser.cpp"
     break;
 
   case 115: // expr_binary: expr "==" expr
 #line 597 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_equality(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2753 "parser.cpp"
+#line 2768 "parser.cpp"
     break;
 
   case 116: // expr_binary: expr "!=" expr
 #line 599 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_inequality(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2759 "parser.cpp"
+#line 2774 "parser.cpp"
     break;
 
   case 117: // expr_binary: expr "<=" expr
 #line 601 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_less_equal(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2765 "parser.cpp"
+#line 2780 "parser.cpp"
     break;
 
   case 118: // expr_binary: expr ">=" expr
 #line 603 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_greater_equal(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2771 "parser.cpp"
+#line 2786 "parser.cpp"
     break;
 
   case 119: // expr_binary: expr "<" expr
 #line 605 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_less(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2777 "parser.cpp"
+#line 2792 "parser.cpp"
     break;
 
   case 120: // expr_binary: expr ">" expr
 #line 607 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_greater(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2783 "parser.cpp"
+#line 2798 "parser.cpp"
     break;
 
   case 121: // expr_binary: expr "|" expr
 #line 609 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_bitwise_or(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2789 "parser.cpp"
+#line 2804 "parser.cpp"
     break;
 
   case 122: // expr_binary: expr "&" expr
 #line 611 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_bitwise_and(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2795 "parser.cpp"
+#line 2810 "parser.cpp"
     break;
 
   case 123: // expr_binary: expr "^" expr
 #line 613 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_bitwise_exor(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2801 "parser.cpp"
+#line 2816 "parser.cpp"
     break;
 
   case 124: // expr_binary: expr "<<" expr
 #line 615 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_shift_left(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2807 "parser.cpp"
+#line 2822 "parser.cpp"
     break;
 
   case 125: // expr_binary: expr ">>" expr
 #line 617 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_shift_right(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2813 "parser.cpp"
+#line 2828 "parser.cpp"
     break;
 
   case 126: // expr_binary: expr "+" expr
 #line 619 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_add(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2819 "parser.cpp"
+#line 2834 "parser.cpp"
     break;
 
   case 127: // expr_binary: expr "-" expr
 #line 621 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_sub(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2825 "parser.cpp"
+#line 2840 "parser.cpp"
     break;
 
   case 128: // expr_binary: expr "*" expr
 #line 623 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_mul(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2831 "parser.cpp"
+#line 2846 "parser.cpp"
     break;
 
   case 129: // expr_binary: expr "/" expr
 #line 625 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_div(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2837 "parser.cpp"
+#line 2852 "parser.cpp"
     break;
 
   case 130: // expr_binary: expr "%" expr
 #line 627 "parser.ypp"
         { yylhs.value.as < expr > ().as_node = make_expr_mod(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr > ())); }
-#line 2843 "parser.cpp"
+#line 2858 "parser.cpp"
     break;
 
   case 131: // expr_primitive: expr_complement
 #line 631 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_complement::ptr > ()); }
-#line 2849 "parser.cpp"
+#line 2864 "parser.cpp"
     break;
 
   case 132: // expr_primitive: expr_negate
 #line 632 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_negate::ptr > ()); }
-#line 2855 "parser.cpp"
+#line 2870 "parser.cpp"
     break;
 
   case 133: // expr_primitive: expr_not
 #line 633 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_not::ptr > ()); }
-#line 2861 "parser.cpp"
+#line 2876 "parser.cpp"
     break;
 
   case 134: // expr_primitive: expr_call
 #line 634 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_call::ptr > ()); }
-#line 2867 "parser.cpp"
+#line 2882 "parser.cpp"
     break;
 
   case 135: // expr_primitive: expr_method
 #line 635 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_method::ptr > ()); }
-#line 2873 "parser.cpp"
+#line 2888 "parser.cpp"
     break;
 
   case 136: // expr_primitive: expr_add_array
 #line 636 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_add_array::ptr > ()); }
-#line 2879 "parser.cpp"
+#line 2894 "parser.cpp"
     break;
 
   case 137: // expr_primitive: expr_isdefined
 #line 637 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_isdefined::ptr > ()); }
-#line 2885 "parser.cpp"
+#line 2900 "parser.cpp"
     break;
 
   case 138: // expr_primitive: expr_istrue
 #line 638 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_istrue::ptr > ()); }
-#line 2891 "parser.cpp"
+#line 2906 "parser.cpp"
     break;
 
   case 139: // expr_primitive: expr_reference
 #line 639 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_reference::ptr > ()); }
-#line 2897 "parser.cpp"
+#line 2912 "parser.cpp"
     break;
 
   case 140: // expr_primitive: expr_array
 #line 640 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_array::ptr > ()); }
-#line 2903 "parser.cpp"
+#line 2918 "parser.cpp"
     break;
 
   case 141: // expr_primitive: expr_field
 #line 641 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_field::ptr > ()); }
-#line 2909 "parser.cpp"
+#line 2924 "parser.cpp"
     break;
 
   case 142: // expr_primitive: expr_size
 #line 642 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_size::ptr > ()); }
-#line 2915 "parser.cpp"
+#line 2930 "parser.cpp"
     break;
 
   case 143: // expr_primitive: expr_paren
 #line 643 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_paren::ptr > ()); }
-#line 2921 "parser.cpp"
+#line 2936 "parser.cpp"
     break;
 
   case 144: // expr_primitive: expr_thisthread
 #line 644 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_thisthread::ptr > ()); }
-#line 2927 "parser.cpp"
+#line 2942 "parser.cpp"
     break;
 
   case 145: // expr_primitive: expr_empty_array
 #line 645 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_empty_array::ptr > ()); }
-#line 2933 "parser.cpp"
+#line 2948 "parser.cpp"
     break;
 
   case 146: // expr_primitive: expr_undefined
 #line 646 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_undefined::ptr > ()); }
-#line 2939 "parser.cpp"
+#line 2954 "parser.cpp"
     break;
 
   case 147: // expr_primitive: expr_game
 #line 647 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_game::ptr > ()); }
-#line 2945 "parser.cpp"
+#line 2960 "parser.cpp"
     break;
 
   case 148: // expr_primitive: expr_self
 #line 648 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_self::ptr > ()); }
-#line 2951 "parser.cpp"
+#line 2966 "parser.cpp"
     break;
 
   case 149: // expr_primitive: expr_anim
 #line 649 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_anim::ptr > ()); }
-#line 2957 "parser.cpp"
+#line 2972 "parser.cpp"
     break;
 
   case 150: // expr_primitive: expr_level
 #line 650 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_level::ptr > ()); }
-#line 2963 "parser.cpp"
+#line 2978 "parser.cpp"
     break;
 
   case 151: // expr_primitive: expr_animation
 #line 651 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_animation::ptr > ()); }
-#line 2969 "parser.cpp"
+#line 2984 "parser.cpp"
     break;
 
   case 152: // expr_primitive: expr_animtree
 #line 652 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_animtree::ptr > ()); }
-#line 2975 "parser.cpp"
+#line 2990 "parser.cpp"
     break;
 
   case 153: // expr_primitive: expr_identifier
 #line 653 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_identifier::ptr > ()); }
-#line 2981 "parser.cpp"
+#line 2996 "parser.cpp"
     break;
 
   case 154: // expr_primitive: expr_istring
 #line 654 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_istring::ptr > ()); }
-#line 2987 "parser.cpp"
+#line 3002 "parser.cpp"
     break;
 
   case 155: // expr_primitive: expr_string
 #line 655 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_string::ptr > ()); }
-#line 2993 "parser.cpp"
+#line 3008 "parser.cpp"
     break;
 
   case 156: // expr_primitive: expr_vector
 #line 656 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_vector::ptr > ()); }
-#line 2999 "parser.cpp"
+#line 3014 "parser.cpp"
     break;
 
   case 157: // expr_primitive: expr_float
 #line 657 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_float::ptr > ()); }
-#line 3005 "parser.cpp"
+#line 3020 "parser.cpp"
     break;
 
   case 158: // expr_primitive: expr_integer
 #line 658 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_integer::ptr > ()); }
-#line 3011 "parser.cpp"
+#line 3026 "parser.cpp"
     break;
 
   case 159: // expr_primitive: expr_false
 #line 659 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_false::ptr > ()); }
-#line 3017 "parser.cpp"
+#line 3032 "parser.cpp"
     break;
 
   case 160: // expr_primitive: expr_true
 #line 660 "parser.ypp"
                             { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_true::ptr > ()); }
-#line 3023 "parser.cpp"
+#line 3038 "parser.cpp"
     break;
 
   case 161: // expr_complement: "~" expr
 #line 665 "parser.ypp"
         { yylhs.value.as < expr_complement::ptr > () = make_expr_complement(yylhs.location, std::move(yystack_[0].value.as < expr > ())); }
-#line 3029 "parser.cpp"
+#line 3044 "parser.cpp"
     break;
 
   case 162: // expr_negate: "-" expr_identifier
 #line 670 "parser.ypp"
         { yylhs.value.as < expr_negate::ptr > () = make_expr_negate(yylhs.location, expr{ std::move(yystack_[0].value.as < expr_identifier::ptr > ()) }); }
-#line 3035 "parser.cpp"
+#line 3050 "parser.cpp"
     break;
 
   case 163: // expr_negate: "-" expr_paren
 #line 672 "parser.ypp"
         { yylhs.value.as < expr_negate::ptr > () = make_expr_negate(yylhs.location, expr{ std::move(yystack_[0].value.as < expr_paren::ptr > ()) }); }
-#line 3041 "parser.cpp"
+#line 3056 "parser.cpp"
     break;
 
   case 164: // expr_negate: "-" expr_array
 #line 674 "parser.ypp"
         { yylhs.value.as < expr_negate::ptr > () = make_expr_negate(yylhs.location, expr{ std::move(yystack_[0].value.as < expr_array::ptr > ()) }); }
-#line 3047 "parser.cpp"
+#line 3062 "parser.cpp"
     break;
 
   case 165: // expr_negate: "-" expr_field
 #line 676 "parser.ypp"
         { yylhs.value.as < expr_negate::ptr > () = make_expr_negate(yylhs.location, expr{ std::move(yystack_[0].value.as < expr_field::ptr > ()) }); }
-#line 3053 "parser.cpp"
+#line 3068 "parser.cpp"
     break;
 
   case 166: // expr_not: "!" expr
 #line 681 "parser.ypp"
         { yylhs.value.as < expr_not::ptr > () = make_expr_not(yylhs.location, std::move(yystack_[0].value.as < expr > ())); }
-#line 3059 "parser.cpp"
+#line 3074 "parser.cpp"
     break;
 
   case 167: // expr_call: expr_function
 #line 685 "parser.ypp"
                                    { yylhs.value.as < expr_call::ptr > () = make_expr_call(yylhs.location, std::move(yystack_[0].value.as < call > ())); }
-#line 3065 "parser.cpp"
+#line 3080 "parser.cpp"
     break;
 
   case 168: // expr_call: expr_pointer
 #line 686 "parser.ypp"
                                    { yylhs.value.as < expr_call::ptr > () = make_expr_call(yylhs.location, std::move(yystack_[0].value.as < call > ())); }
-#line 3071 "parser.cpp"
+#line 3086 "parser.cpp"
     break;
 
   case 169: // expr_method: expr_object expr_function
 #line 689 "parser.ypp"
                                    { yylhs.value.as < expr_method::ptr > () = make_expr_method(yylhs.location, std::move(yystack_[1].value.as < expr > ()), std::move(yystack_[0].value.as < call > ())); }
-#line 3077 "parser.cpp"
+#line 3092 "parser.cpp"
     break;
 
   case 170: // expr_method: expr_object expr_pointer
 #line 690 "parser.ypp"
                                    { yylhs.value.as < expr_method::ptr > () = make_expr_method(yylhs.location, std::move(yystack_[1].value.as < expr > ()), std::move(yystack_[0].value.as < call > ())); }
-#line 3083 "parser.cpp"
+#line 3098 "parser.cpp"
     break;
 
   case 171: // expr_function: expr_identifier "(" expr_arguments ")"
 #line 695 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, make_expr_path(yylhs.location), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::normal); }
-#line 3089 "parser.cpp"
+#line 3104 "parser.cpp"
     break;
 
   case 172: // expr_function: expr_path "::" expr_identifier "(" expr_arguments ")"
 #line 697 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, std::move(yystack_[5].value.as < expr_path::ptr > ()), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::normal); }
-#line 3095 "parser.cpp"
+#line 3110 "parser.cpp"
     break;
 
   case 173: // expr_function: "thread" expr_identifier "(" expr_arguments ")"
 #line 699 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, make_expr_path(yylhs.location), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::thread); }
-#line 3101 "parser.cpp"
+#line 3116 "parser.cpp"
     break;
 
   case 174: // expr_function: "thread" expr_path "::" expr_identifier "(" expr_arguments ")"
 #line 701 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, std::move(yystack_[5].value.as < expr_path::ptr > ()), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::thread); }
-#line 3107 "parser.cpp"
+#line 3122 "parser.cpp"
     break;
 
   case 175: // expr_function: "childthread" expr_identifier "(" expr_arguments ")"
 #line 703 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, make_expr_path(yylhs.location), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::childthread); }
-#line 3113 "parser.cpp"
+#line 3128 "parser.cpp"
     break;
 
   case 176: // expr_function: "childthread" expr_path "::" expr_identifier "(" expr_arguments ")"
 #line 705 "parser.ypp"
         { yylhs.value.as < call > ().as_function = make_expr_function(yylhs.location, std::move(yystack_[5].value.as < expr_path::ptr > ()), std::move(yystack_[3].value.as < expr_identifier::ptr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::childthread); }
-#line 3119 "parser.cpp"
+#line 3134 "parser.cpp"
     break;
 
   case 177: // expr_pointer: "[" "[" expr "]" "]" "(" expr_arguments ")"
 #line 710 "parser.ypp"
         { yylhs.value.as < call > ().as_pointer = make_expr_pointer(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::normal); }
-#line 3125 "parser.cpp"
+#line 3140 "parser.cpp"
     break;
 
   case 178: // expr_pointer: "thread" "[" "[" expr "]" "]" "(" expr_arguments ")"
 #line 712 "parser.ypp"
         { yylhs.value.as < call > ().as_pointer = make_expr_pointer(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::thread); }
-#line 3131 "parser.cpp"
+#line 3146 "parser.cpp"
     break;
 
   case 179: // expr_pointer: "childthread" "[" "[" expr "]" "]" "(" expr_arguments ")"
 #line 714 "parser.ypp"
         { yylhs.value.as < call > ().as_pointer = make_expr_pointer(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::childthread); }
-#line 3137 "parser.cpp"
+#line 3152 "parser.cpp"
     break;
 
   case 180: // expr_pointer: "call" "[" "[" expr "]" "]" "(" expr_arguments ")"
 #line 716 "parser.ypp"
         { yylhs.value.as < call > ().as_pointer = make_expr_pointer(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[1].value.as < expr_arguments::ptr > ()), call::mode::builtin); }
-#line 3143 "parser.cpp"
+#line 3158 "parser.cpp"
     break;
 
   case 181: // expr_add_array: "[" expr_arguments_no_empty "]"
 #line 721 "parser.ypp"
         { yylhs.value.as < expr_add_array::ptr > () = make_expr_add_array(yylhs.location, std::move(yystack_[1].value.as < expr_arguments::ptr > ())); }
-#line 3149 "parser.cpp"
+#line 3164 "parser.cpp"
     break;
 
   case 182: // expr_parameters: expr_parameters "," expr_identifier
 #line 726 "parser.ypp"
         { yylhs.value.as < expr_parameters::ptr > () = std::move(yystack_[2].value.as < expr_parameters::ptr > ()); yylhs.value.as < expr_parameters::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr_identifier::ptr > ())); }
-#line 3155 "parser.cpp"
+#line 3170 "parser.cpp"
     break;
 
   case 183: // expr_parameters: expr_identifier
 #line 728 "parser.ypp"
         { yylhs.value.as < expr_parameters::ptr > () = make_expr_parameters(yylhs.location); yylhs.value.as < expr_parameters::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr_identifier::ptr > ())); }
-#line 3161 "parser.cpp"
+#line 3176 "parser.cpp"
     break;
 
   case 184: // expr_parameters: %empty
 #line 730 "parser.ypp"
         { yylhs.value.as < expr_parameters::ptr > () = make_expr_parameters(yylhs.location); }
-#line 3167 "parser.cpp"
+#line 3182 "parser.cpp"
     break;
 
   case 185: // expr_arguments: expr_arguments_no_empty
 #line 735 "parser.ypp"
         { yylhs.value.as < expr_arguments::ptr > () = std::move(yystack_[0].value.as < expr_arguments::ptr > ()); }
-#line 3173 "parser.cpp"
+#line 3188 "parser.cpp"
     break;
 
   case 186: // expr_arguments: %empty
 #line 737 "parser.ypp"
         { yylhs.value.as < expr_arguments::ptr > () = make_expr_arguments(yylhs.location); }
-#line 3179 "parser.cpp"
+#line 3194 "parser.cpp"
     break;
 
   case 187: // expr_arguments_no_empty: expr_arguments "," expr
 #line 742 "parser.ypp"
         { yylhs.value.as < expr_arguments::ptr > () = std::move(yystack_[2].value.as < expr_arguments::ptr > ()); yylhs.value.as < expr_arguments::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr > ())); }
-#line 3185 "parser.cpp"
+#line 3200 "parser.cpp"
     break;
 
   case 188: // expr_arguments_no_empty: expr
 #line 744 "parser.ypp"
         { yylhs.value.as < expr_arguments::ptr > () = make_expr_arguments(yylhs.location); yylhs.value.as < expr_arguments::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr > ())); }
-#line 3191 "parser.cpp"
+#line 3206 "parser.cpp"
     break;
 
   case 189: // expr_isdefined: "isdefined" "(" expr ")"
 #line 749 "parser.ypp"
         { yylhs.value.as < expr_isdefined::ptr > () = make_expr_isdefined(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 3197 "parser.cpp"
+#line 3212 "parser.cpp"
     break;
 
   case 190: // expr_istrue: "istrue" "(" expr ")"
 #line 754 "parser.ypp"
         { yylhs.value.as < expr_istrue::ptr > () = make_expr_istrue(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 3203 "parser.cpp"
+#line 3218 "parser.cpp"
     break;
 
   case 191: // expr_reference: "::" expr_identifier
 #line 759 "parser.ypp"
         { yylhs.value.as < expr_reference::ptr > () = make_expr_reference(yylhs.location, make_expr_path(yylhs.location), std::move(yystack_[0].value.as < expr_identifier::ptr > ())); }
-#line 3209 "parser.cpp"
+#line 3224 "parser.cpp"
     break;
 
   case 192: // expr_reference: expr_path "::" expr_identifier
 #line 761 "parser.ypp"
         { yylhs.value.as < expr_reference::ptr > () = make_expr_reference(yylhs.location, std::move(yystack_[2].value.as < expr_path::ptr > ()), std::move(yystack_[0].value.as < expr_identifier::ptr > ())); }
-#line 3215 "parser.cpp"
+#line 3230 "parser.cpp"
     break;
 
   case 193: // expr_tuple: "[" expr_tuple_arguments "]"
@@ -3219,263 +3234,263 @@ namespace xsk { namespace gsc {
         { yylhs.value.as < expr > ().as_node = std::move(yystack_[1].value.as < expr_tuple::ptr > ());
           yylhs.value.as < expr > ().as_tuple->temp = expr{ std::make_unique<expr_identifier>(yylhs.value.as < expr > ().loc(), fmt::format("_temp_{}", ++index)) };
         }
-#line 3223 "parser.cpp"
+#line 3238 "parser.cpp"
     break;
 
   case 194: // expr_tuple_arguments: expr_tuple_arguments "," expr_tuple_types
 #line 773 "parser.ypp"
         { yylhs.value.as < expr_tuple::ptr > () = std::move(yystack_[2].value.as < expr_tuple::ptr > ()); yylhs.value.as < expr_tuple::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr > ())); }
-#line 3229 "parser.cpp"
+#line 3244 "parser.cpp"
     break;
 
   case 195: // expr_tuple_arguments: expr_tuple_types
 #line 775 "parser.ypp"
         { yylhs.value.as < expr_tuple::ptr > () = make_expr_tuple(yylhs.location); yylhs.value.as < expr_tuple::ptr > ()->list.push_back(std::move(yystack_[0].value.as < expr > ())); }
-#line 3235 "parser.cpp"
+#line 3250 "parser.cpp"
     break;
 
   case 196: // expr_tuple_types: expr_array
 #line 779 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_array::ptr > ()); }
-#line 3241 "parser.cpp"
+#line 3256 "parser.cpp"
     break;
 
   case 197: // expr_tuple_types: expr_field
 #line 780 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_field::ptr > ()); }
-#line 3247 "parser.cpp"
+#line 3262 "parser.cpp"
     break;
 
   case 198: // expr_tuple_types: expr_identifier
 #line 781 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_identifier::ptr > ()); }
-#line 3253 "parser.cpp"
+#line 3268 "parser.cpp"
     break;
 
   case 199: // expr_array: expr_object "[" expr "]"
 #line 786 "parser.ypp"
         { yylhs.value.as < expr_array::ptr > () = make_expr_array(yylhs.location, std::move(yystack_[3].value.as < expr > ()), std::move(yystack_[1].value.as < expr > ())); }
-#line 3259 "parser.cpp"
+#line 3274 "parser.cpp"
     break;
 
   case 200: // expr_field: expr_object "." expr_identifier_nosize
 #line 791 "parser.ypp"
         { yylhs.value.as < expr_field::ptr > () = make_expr_field(yylhs.location, std::move(yystack_[2].value.as < expr > ()), std::move(yystack_[0].value.as < expr_identifier::ptr > ())); }
-#line 3265 "parser.cpp"
+#line 3280 "parser.cpp"
     break;
 
   case 201: // expr_size: expr_object "." "size"
 #line 796 "parser.ypp"
         { yylhs.value.as < expr_size::ptr > () = make_expr_size(yylhs.location, std::move(yystack_[2].value.as < expr > ())); }
-#line 3271 "parser.cpp"
+#line 3286 "parser.cpp"
     break;
 
   case 202: // expr_paren: "(" expr ")"
 #line 801 "parser.ypp"
         { yylhs.value.as < expr_paren::ptr > () = make_expr_paren(yylhs.location, std::move(yystack_[1].value.as < expr > ())); }
-#line 3277 "parser.cpp"
+#line 3292 "parser.cpp"
     break;
 
   case 203: // expr_object: expr_call
 #line 805 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_call::ptr > ()); }
-#line 3283 "parser.cpp"
+#line 3298 "parser.cpp"
     break;
 
   case 204: // expr_object: expr_method
 #line 806 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_method::ptr > ()); }
-#line 3289 "parser.cpp"
+#line 3304 "parser.cpp"
     break;
 
   case 205: // expr_object: expr_array
 #line 807 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_array::ptr > ()); }
-#line 3295 "parser.cpp"
+#line 3310 "parser.cpp"
     break;
 
   case 206: // expr_object: expr_field
 #line 808 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_field::ptr > ()); }
-#line 3301 "parser.cpp"
+#line 3316 "parser.cpp"
     break;
 
   case 207: // expr_object: expr_game
 #line 809 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_game::ptr > ()); }
-#line 3307 "parser.cpp"
+#line 3322 "parser.cpp"
     break;
 
   case 208: // expr_object: expr_self
 #line 810 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_self::ptr > ()); }
-#line 3313 "parser.cpp"
+#line 3328 "parser.cpp"
     break;
 
   case 209: // expr_object: expr_anim
 #line 811 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_anim::ptr > ()); }
-#line 3319 "parser.cpp"
+#line 3334 "parser.cpp"
     break;
 
   case 210: // expr_object: expr_level
 #line 812 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_level::ptr > ()); }
-#line 3325 "parser.cpp"
+#line 3340 "parser.cpp"
     break;
 
   case 211: // expr_object: expr_identifier
 #line 813 "parser.ypp"
                       { yylhs.value.as < expr > ().as_node = std::move(yystack_[0].value.as < expr_identifier::ptr > ()); }
-#line 3331 "parser.cpp"
+#line 3346 "parser.cpp"
     break;
 
   case 212: // expr_thisthread: "thisthread"
 #line 818 "parser.ypp"
         { yylhs.value.as < expr_thisthread::ptr > () = make_expr_thisthread(yylhs.location); }
-#line 3337 "parser.cpp"
+#line 3352 "parser.cpp"
     break;
 
   case 213: // expr_empty_array: "[" "]"
 #line 823 "parser.ypp"
         { yylhs.value.as < expr_empty_array::ptr > () = make_expr_empty_array(yylhs.location); }
-#line 3343 "parser.cpp"
+#line 3358 "parser.cpp"
     break;
 
   case 214: // expr_undefined: "undefined"
 #line 828 "parser.ypp"
         { yylhs.value.as < expr_undefined::ptr > () = make_expr_undefined(yylhs.location); }
-#line 3349 "parser.cpp"
+#line 3364 "parser.cpp"
     break;
 
   case 215: // expr_game: "game"
 #line 833 "parser.ypp"
         { yylhs.value.as < expr_game::ptr > () = make_expr_game(yylhs.location); }
-#line 3355 "parser.cpp"
+#line 3370 "parser.cpp"
     break;
 
   case 216: // expr_self: "self"
 #line 838 "parser.ypp"
         { yylhs.value.as < expr_self::ptr > () = make_expr_self(yylhs.location); }
-#line 3361 "parser.cpp"
+#line 3376 "parser.cpp"
     break;
 
   case 217: // expr_anim: "anim"
 #line 843 "parser.ypp"
         { yylhs.value.as < expr_anim::ptr > () = make_expr_anim(yylhs.location); }
-#line 3367 "parser.cpp"
+#line 3382 "parser.cpp"
     break;
 
   case 218: // expr_level: "level"
 #line 848 "parser.ypp"
         { yylhs.value.as < expr_level::ptr > () = make_expr_level(yylhs.location); }
-#line 3373 "parser.cpp"
+#line 3388 "parser.cpp"
     break;
 
   case 219: // expr_animation: "%" "identifier"
 #line 853 "parser.ypp"
         { yylhs.value.as < expr_animation::ptr > () = make_expr_animation(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3379 "parser.cpp"
+#line 3394 "parser.cpp"
     break;
 
   case 220: // expr_animtree: "#animtree"
 #line 858 "parser.ypp"
         { yylhs.value.as < expr_animtree::ptr > () = make_expr_animtree(yylhs.location); }
-#line 3385 "parser.cpp"
+#line 3400 "parser.cpp"
     break;
 
   case 221: // expr_identifier_nosize: "identifier"
 #line 863 "parser.ypp"
         { yylhs.value.as < expr_identifier::ptr > () = make_expr_identifier(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3391 "parser.cpp"
+#line 3406 "parser.cpp"
     break;
 
   case 222: // expr_identifier: "identifier"
 #line 868 "parser.ypp"
         { yylhs.value.as < expr_identifier::ptr > () = make_expr_identifier(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3397 "parser.cpp"
+#line 3412 "parser.cpp"
     break;
 
   case 223: // expr_identifier: "size"
 #line 870 "parser.ypp"
         { yylhs.value.as < expr_identifier::ptr > () = make_expr_identifier(yylhs.location, "size"); }
-#line 3403 "parser.cpp"
+#line 3418 "parser.cpp"
     break;
 
   case 224: // expr_path: "path" "/" "identifier"
 #line 875 "parser.ypp"
         { yylhs.value.as < expr_path::ptr > () = make_expr_path(yylhs.location, yystack_[2].value.as < std::string > () + "/" + yystack_[0].value.as < std::string > ()); }
-#line 3409 "parser.cpp"
+#line 3424 "parser.cpp"
     break;
 
   case 225: // expr_path: "identifier"
 #line 877 "parser.ypp"
         { yylhs.value.as < expr_path::ptr > () = make_expr_path(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3415 "parser.cpp"
+#line 3430 "parser.cpp"
     break;
 
   case 226: // expr_path: "path"
 #line 879 "parser.ypp"
         { yylhs.value.as < expr_path::ptr > () = make_expr_path(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3421 "parser.cpp"
+#line 3436 "parser.cpp"
     break;
 
   case 227: // expr_istring: "localized string"
 #line 884 "parser.ypp"
         { yylhs.value.as < expr_istring::ptr > () = make_expr_istring(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3427 "parser.cpp"
+#line 3442 "parser.cpp"
     break;
 
   case 228: // expr_string: "string literal"
 #line 889 "parser.ypp"
         { yylhs.value.as < expr_string::ptr > () = make_expr_string(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3433 "parser.cpp"
+#line 3448 "parser.cpp"
     break;
 
   case 229: // expr_vector: "(" expr "," expr "," expr ")"
 #line 894 "parser.ypp"
         { yylhs.value.as < expr_vector::ptr > () = make_expr_vector(yylhs.location, std::move(yystack_[5].value.as < expr > ()), std::move(yystack_[3].value.as < expr > ()), std::move(yystack_[1].value.as < expr > ())); }
-#line 3439 "parser.cpp"
+#line 3454 "parser.cpp"
     break;
 
   case 230: // expr_float: "-" "float"
 #line 899 "parser.ypp"
         { yylhs.value.as < expr_float::ptr > () = make_expr_float(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
-#line 3445 "parser.cpp"
+#line 3460 "parser.cpp"
     break;
 
   case 231: // expr_float: "float"
 #line 901 "parser.ypp"
         { yylhs.value.as < expr_float::ptr > () = make_expr_float(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3451 "parser.cpp"
+#line 3466 "parser.cpp"
     break;
 
   case 232: // expr_integer: "-" "integer"
 #line 906 "parser.ypp"
         { yylhs.value.as < expr_integer::ptr > () = make_expr_integer(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
-#line 3457 "parser.cpp"
+#line 3472 "parser.cpp"
     break;
 
   case 233: // expr_integer: "integer"
 #line 908 "parser.ypp"
         { yylhs.value.as < expr_integer::ptr > () = make_expr_integer(yylhs.location, yystack_[0].value.as < std::string > ()); }
-#line 3463 "parser.cpp"
+#line 3478 "parser.cpp"
     break;
 
   case 234: // expr_false: "false"
 #line 913 "parser.ypp"
         { yylhs.value.as < expr_false::ptr > () = make_expr_false(yylhs.location); }
-#line 3469 "parser.cpp"
+#line 3484 "parser.cpp"
     break;
 
   case 235: // expr_true: "true"
 #line 918 "parser.ypp"
         { yylhs.value.as < expr_true::ptr > () = make_expr_true(yylhs.location); }
-#line 3475 "parser.cpp"
+#line 3490 "parser.cpp"
     break;
 
 
-#line 3479 "parser.cpp"
+#line 3494 "parser.cpp"
 
             default:
               break;
@@ -3675,7 +3690,7 @@ namespace xsk { namespace gsc {
   "SIZEOF", "ADD_ARRAY", "THEN", "TERN", "NEG", "ANIMREF", "PREINC",
   "PREDEC", "POSTINC", "POSTDEC", "$accept", "root", "program", "inline",
   "include", "declaration", "decl_usingtree", "decl_function", "stmt",
-  "stmt_or_dev", "stmt_list", "stmt_or_dev_list", "stmt_dev", "stmt_block",
+  "stmt_or_dev", "stmt_list", "stmt_or_dev_list", "stmt_dev", "stmt_comp",
   "stmt_expr", "stmt_call", "stmt_assign", "stmt_endon", "stmt_notify",
   "stmt_wait", "stmt_waittill", "stmt_waittillmatch",
   "stmt_waittillframeend", "stmt_waitframe", "stmt_if", "stmt_ifelse",
@@ -4768,7 +4783,7 @@ namespace xsk { namespace gsc {
 
 #line 13 "parser.ypp"
 } } // xsk::gsc
-#line 4772 "parser.cpp"
+#line 4787 "parser.cpp"
 
 #line 921 "parser.ypp"
 
@@ -4783,14 +4798,14 @@ void parser::error(location const& loc, std::string const& msg)
 
 auto parse_switch(stmt_switch& stm) -> void
 {
-    auto body = make_stmt_list(stm.body->loc());
+    auto body = make_stmt_list(stm.body->block->loc());
     auto current_case = stmt{ nullptr };
 
-    auto num = stm.body->list.size();
+    auto num = stm.body->block->list.size();
 
     for (auto i = 0u; i < num; i++)
     {
-        auto& entry = stm.body->list[0];
+        auto& entry = stm.body->block->list[0];
 
         if (entry == node::stmt_case || entry == node::stmt_default)
         {
@@ -4799,8 +4814,8 @@ auto parse_switch(stmt_switch& stm) -> void
                 body->list.push_back(std::move(current_case));
             }
 
-            current_case = std::move(stm.body->list[0]);
-            stm.body->list.erase(stm.body->list.begin());
+            current_case = std::move(stm.body->block->list[0]);
+            stm.body->block->list.erase(stm.body->block->list.begin());
         }
         else
         {
@@ -4809,12 +4824,12 @@ auto parse_switch(stmt_switch& stm) -> void
                 if (current_case == node::stmt_case)
                 {
                     current_case.as_case->body->list.push_back(std::move(entry));
-                    stm.body->list.erase(stm.body->list.begin());
+                    stm.body->block->list.erase(stm.body->block->list.begin());
                 }
                 else
                 {
                     current_case.as_default->body->list.push_back(std::move(entry));
-                    stm.body->list.erase(stm.body->list.begin());
+                    stm.body->block->list.erase(stm.body->block->list.begin());
                 }
             }
             else
@@ -4829,7 +4844,7 @@ auto parse_switch(stmt_switch& stm) -> void
         body->list.push_back(std::move(current_case));
     }
 
-    stm.body = std::move(body);
+    stm.body->block = std::move(body);
 }
 
 } // namespace xsk::gsc
diff --git a/src/gsc/parser.hpp b/src/gsc/parser.hpp
index 172c7217..0c1629fe 100644
--- a/src/gsc/parser.hpp
+++ b/src/gsc/parser.hpp
@@ -585,73 +585,75 @@ namespace xsk { namespace gsc {
       // stmt_case
       char dummy48[sizeof (stmt_case::ptr)];
 
+      // stmt_comp
+      char dummy49[sizeof (stmt_comp::ptr)];
+
       // stmt_continue
-      char dummy49[sizeof (stmt_continue::ptr)];
+      char dummy50[sizeof (stmt_continue::ptr)];
 
       // stmt_default
-      char dummy50[sizeof (stmt_default::ptr)];
+      char dummy51[sizeof (stmt_default::ptr)];
 
       // stmt_dev
-      char dummy51[sizeof (stmt_dev::ptr)];
+      char dummy52[sizeof (stmt_dev::ptr)];
 
       // stmt_dowhile
-      char dummy52[sizeof (stmt_dowhile::ptr)];
+      char dummy53[sizeof (stmt_dowhile::ptr)];
 
       // stmt_endon
-      char dummy53[sizeof (stmt_endon::ptr)];
+      char dummy54[sizeof (stmt_endon::ptr)];
 
       // stmt_expr
-      char dummy54[sizeof (stmt_expr::ptr)];
+      char dummy55[sizeof (stmt_expr::ptr)];
 
       // stmt_for
-      char dummy55[sizeof (stmt_for::ptr)];
+      char dummy56[sizeof (stmt_for::ptr)];
 
       // stmt_foreach
-      char dummy56[sizeof (stmt_foreach::ptr)];
+      char dummy57[sizeof (stmt_foreach::ptr)];
 
       // stmt_if
-      char dummy57[sizeof (stmt_if::ptr)];
+      char dummy58[sizeof (stmt_if::ptr)];
 
       // stmt_ifelse
-      char dummy58[sizeof (stmt_ifelse::ptr)];
+      char dummy59[sizeof (stmt_ifelse::ptr)];
 
       // stmt_list
       // stmt_or_dev_list
-      // stmt_block
-      char dummy59[sizeof (stmt_list::ptr)];
+      char dummy60[sizeof (stmt_list::ptr)];
 
       // stmt_notify
-      char dummy60[sizeof (stmt_notify::ptr)];
+      char dummy61[sizeof (stmt_notify::ptr)];
 
       // stmt_prof_begin
-      char dummy61[sizeof (stmt_prof_begin::ptr)];
+      char dummy62[sizeof (stmt_prof_begin::ptr)];
 
       // stmt_prof_end
-      char dummy62[sizeof (stmt_prof_end::ptr)];
+      char dummy63[sizeof (stmt_prof_end::ptr)];
 
       // stmt_return
-      char dummy63[sizeof (stmt_return::ptr)];
+      char dummy64[sizeof (stmt_return::ptr)];
 
       // stmt_switch
-      char dummy64[sizeof (stmt_switch::ptr)];
+      char dummy65[sizeof (stmt_switch::ptr)];
 
       // stmt_wait
-      char dummy65[sizeof (stmt_wait::ptr)];
+      char dummy66[sizeof (stmt_wait::ptr)];
 
       // stmt_waitframe
-      char dummy66[sizeof (stmt_waitframe::ptr)];
+      char dummy67[sizeof (stmt_waitframe::ptr)];
 
       // stmt_waittill
-      char dummy67[sizeof (stmt_waittill::ptr)];
+      char dummy68[sizeof (stmt_waittill::ptr)];
 
       // stmt_waittillframeend
-      char dummy68[sizeof (stmt_waittillframeend::ptr)];
+      char dummy69[sizeof (stmt_waittillframeend::ptr)];
 
       // stmt_waittillmatch
-      char dummy69[sizeof (stmt_waittillmatch::ptr)];
+      char dummy70[sizeof (stmt_waittillmatch::ptr)];
 
       // stmt_while
-      char dummy70[sizeof (stmt_while::ptr)];
+      char dummy71[sizeof (stmt_while::ptr)];
     };
 
     /// The size of the largest semantic type.
@@ -962,7 +964,7 @@ namespace xsk { namespace gsc {
         S_stmt_list = 125,                       // stmt_list
         S_stmt_or_dev_list = 126,                // stmt_or_dev_list
         S_stmt_dev = 127,                        // stmt_dev
-        S_stmt_block = 128,                      // stmt_block
+        S_stmt_comp = 128,                       // stmt_comp
         S_stmt_expr = 129,                       // stmt_expr
         S_stmt_call = 130,                       // stmt_call
         S_stmt_assign = 131,                     // stmt_assign
@@ -1284,6 +1286,10 @@ namespace xsk { namespace gsc {
         value.move< stmt_case::ptr > (std::move (that.value));
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.move< stmt_comp::ptr > (std::move (that.value));
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.move< stmt_continue::ptr > (std::move (that.value));
         break;
@@ -1326,7 +1332,6 @@ namespace xsk { namespace gsc {
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.move< stmt_list::ptr > (std::move (that.value));
         break;
 
@@ -2069,6 +2074,20 @@ namespace xsk { namespace gsc {
       {}
 #endif
 
+#if 201103L <= YY_CPLUSPLUS
+      basic_symbol (typename Base::kind_type t, stmt_comp::ptr&& v, location_type&& l)
+        : Base (t)
+        , value (std::move (v))
+        , location (std::move (l))
+      {}
+#else
+      basic_symbol (typename Base::kind_type t, const stmt_comp::ptr& v, const location_type& l)
+        : Base (t)
+        , value (v)
+        , location (l)
+      {}
+#endif
+
 #if 201103L <= YY_CPLUSPLUS
       basic_symbol (typename Base::kind_type t, stmt_continue::ptr&& v, location_type&& l)
         : Base (t)
@@ -2612,6 +2631,10 @@ switch (yykind)
         value.template destroy< stmt_case::ptr > ();
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.template destroy< stmt_comp::ptr > ();
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.template destroy< stmt_continue::ptr > ();
         break;
@@ -2654,7 +2677,6 @@ switch (yykind)
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.template destroy< stmt_list::ptr > ();
         break;
 
@@ -5174,6 +5196,10 @@ switch (yykind)
         value.copy< stmt_case::ptr > (YY_MOVE (that.value));
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.copy< stmt_comp::ptr > (YY_MOVE (that.value));
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.copy< stmt_continue::ptr > (YY_MOVE (that.value));
         break;
@@ -5216,7 +5242,6 @@ switch (yykind)
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.copy< stmt_list::ptr > (YY_MOVE (that.value));
         break;
 
@@ -5506,6 +5531,10 @@ switch (yykind)
         value.move< stmt_case::ptr > (YY_MOVE (s.value));
         break;
 
+      case symbol_kind::S_stmt_comp: // stmt_comp
+        value.move< stmt_comp::ptr > (YY_MOVE (s.value));
+        break;
+
       case symbol_kind::S_stmt_continue: // stmt_continue
         value.move< stmt_continue::ptr > (YY_MOVE (s.value));
         break;
@@ -5548,7 +5577,6 @@ switch (yykind)
 
       case symbol_kind::S_stmt_list: // stmt_list
       case symbol_kind::S_stmt_or_dev_list: // stmt_or_dev_list
-      case symbol_kind::S_stmt_block: // stmt_block
         value.move< stmt_list::ptr > (YY_MOVE (s.value));
         break;
 
@@ -5663,7 +5691,7 @@ switch (yykind)
 
 #line 13 "parser.ypp"
 } } // xsk::gsc
-#line 5667 "parser.hpp"
+#line 5695 "parser.hpp"
 
 
 
diff --git a/src/gsc/source.cpp b/src/gsc/source.cpp
index ca46f3ac..e0e2c125 100644
--- a/src/gsc/source.cpp
+++ b/src/gsc/source.cpp
@@ -345,7 +345,7 @@ auto source::dump_decl_function(decl_function const& dec) -> void
     fmt::format_to(std::back_inserter(buf_), "(");
     dump_expr_parameters(*dec.params);
     fmt::format_to(std::back_inserter(buf_), ")\n");
-    dump_stmt_list(*dec.body);
+    dump_stmt_comp(*dec.body);
     fmt::format_to(std::back_inserter(buf_), "\n");
 }
 
@@ -356,6 +356,9 @@ auto source::dump_stmt(stmt const& stm) -> void
         case node::stmt_list:
             dump_stmt_list(*stm.as_list);
             break;
+        case node::stmt_comp:
+            dump_stmt_comp(*stm.as_comp);
+            break;
         case node::stmt_dev:
             dump_stmt_dev(*stm.as_dev);
             break;
@@ -468,22 +471,7 @@ auto source::dump_stmt(stmt const& stm) -> void
 
 auto source::dump_stmt_list(stmt_list const& stm) -> void
 {
-    if (stm.is_expr)
-    {
-        if (stm.list.size() > 0)
-        {
-            dump_stmt(stm.list[0]);
-            buf_.pop_back();
-        }
-
-        return;
-    }
-
-    bool last_special = false;
-
-    if (!stm.is_case)
-        fmt::format_to(std::back_inserter(buf_), "{: >{}}\n", "{", indent_ + 1);
-    
+    auto last_special = false;
     indent_ += 4;
 
     for (auto const& entry : stm.list)
@@ -511,39 +499,19 @@ auto source::dump_stmt_list(stmt_list const& stm) -> void
     }
 
     indent_ -= 4;
+}
 
-    if (!stm.is_case)
-        fmt::format_to(std::back_inserter(buf_), "\n{: >{}}", "}", indent_ + 1);
+auto source::dump_stmt_comp(stmt_comp const& stm) -> void
+{
+    fmt::format_to(std::back_inserter(buf_), "{: >{}}\n", "{", indent_ + 1);
+    dump_stmt_list(*stm.block);
+    fmt::format_to(std::back_inserter(buf_), "\n{: >{}}", "}", indent_ + 1);
 }
 
 auto source::dump_stmt_dev(stmt_dev const& stm) -> void
 {
-    bool last_special = false;
-
     fmt::format_to(std::back_inserter(buf_), "/#\n");
-
-    for (auto const& entry : stm.body->list)
-    {
-        if ((&entry != &stm.body->list.front() && entry.as_node->is_special_stmt()) || last_special)
-            fmt::format_to(std::back_inserter(buf_), "\n");
-
-        if (entry == node::stmt_dev)
-            dump_stmt(entry);
-        else
-        {
-            fmt::format_to(std::back_inserter(buf_), "{: >{}}", "", indent_);
-            dump_stmt(entry);
-        }
-
-        if (&entry != &stm.body->list.back())
-            fmt::format_to(std::back_inserter(buf_), "\n");
-
-        if (entry.as_node->is_special_stmt())
-            last_special = true;
-        else
-            last_special = false;
-    }
-
+    dump_stmt_list(*stm.block);
     fmt::format_to(std::back_inserter(buf_), "\n#/");
 }
 
@@ -661,7 +629,7 @@ auto source::dump_stmt_if(stmt_if const& stm) -> void
     dump_expr(stm.test);
     fmt::format_to(std::back_inserter(buf_), " )\n");
 
-    if (stm.body == node::stmt_list)
+    if (stm.body == node::stmt_comp)
     {
         dump_stmt(stm.body);
     }
@@ -680,7 +648,7 @@ auto source::dump_stmt_ifelse(stmt_ifelse const& stm) -> void
     dump_expr(stm.test);
     fmt::format_to(std::back_inserter(buf_), " )\n");
 
-    if (stm.stmt_if == node::stmt_list)
+    if (stm.stmt_if == node::stmt_comp)
     {
         dump_stmt(stm.stmt_if);
     }
@@ -694,7 +662,7 @@ auto source::dump_stmt_ifelse(stmt_ifelse const& stm) -> void
 
     fmt::format_to(std::back_inserter(buf_), "\n{: >{}}else", "", indent_);
 
-    if (stm.stmt_else == node::stmt_list)
+    if (stm.stmt_else == node::stmt_comp)
     {
         fmt::format_to(std::back_inserter(buf_), "\n");
         dump_stmt(stm.stmt_else);
@@ -729,7 +697,7 @@ auto source::dump_stmt_while(stmt_while const& stm) -> void
         fmt::format_to(std::back_inserter(buf_), " )\n");
     }
 
-    if (stm.body == node::stmt_list)
+    if (stm.body == node::stmt_comp)
     {
         dump_stmt(stm.body);
     }
@@ -746,7 +714,7 @@ auto source::dump_stmt_dowhile(stmt_dowhile const& stm) -> void
 {
     fmt::format_to(std::back_inserter(buf_), "do\n");
 
-    if (stm.body == node::stmt_list)
+    if (stm.body == node::stmt_comp)
     {
         dump_stmt(stm.body);
     }
@@ -787,7 +755,7 @@ auto source::dump_stmt_for(stmt_for const& stm) -> void
         fmt::format_to(std::back_inserter(buf_), " )\n");
     }
 
-    if (stm.body == node::stmt_list)
+    if (stm.body == node::stmt_comp)
     {
         dump_stmt(stm.body);
     }
@@ -815,7 +783,7 @@ auto source::dump_stmt_foreach(stmt_foreach const& stm) -> void
     dump_expr(stm.container);
     fmt::format_to(std::back_inserter(buf_), " )\n");
 
-    if (stm.body == node::stmt_list)
+    if (stm.body == node::stmt_comp)
     {
         dump_stmt(stm.body);
     }
@@ -833,7 +801,7 @@ auto source::dump_stmt_switch(stmt_switch const& stm) -> void
     fmt::format_to(std::back_inserter(buf_), "switch ( ");
     dump_expr(stm.test);
     fmt::format_to(std::back_inserter(buf_), " )\n");
-    dump_stmt_list(*stm.body);
+    dump_stmt_comp(*stm.body);
 }
 
 auto source::dump_stmt_case(stmt_case const& stm) -> void
diff --git a/src/gsc/source.hpp b/src/gsc/source.hpp
index 3705a32c..144cdd25 100644
--- a/src/gsc/source.hpp
+++ b/src/gsc/source.hpp
@@ -40,6 +40,7 @@ private:
     auto dump_decl_function(decl_function const& dec) -> void;
     auto dump_stmt(stmt const& stm) -> void;
     auto dump_stmt_list(stmt_list const& stm) -> void;
+    auto dump_stmt_comp(stmt_comp const& stm) -> void;
     auto dump_stmt_dev(stmt_dev const& stm) -> void;
     auto dump_stmt_expr(stmt_expr const& stm) -> void;
     auto dump_stmt_call(stmt_call const& stm) -> void;
diff --git a/src/t6/parser.cpp b/src/t6/parser.cpp
index d58e6c9b..bd787313 100644
--- a/src/t6/parser.cpp
+++ b/src/t6/parser.cpp
@@ -36,12 +36,12 @@
 
 // "%code top" blocks.
 #line 38 "parser.ypp"
-
-#include "stdinc.hpp"
-#include "parser.hpp"
-#include "lexer.hpp"
-using namespace xsk::arc;
-xsk::arc::t6::parser::symbol_type T6lex(xsk::arc::t6::lexer& lexer);
+
+#include "stdinc.hpp"
+#include "parser.hpp"
+#include "lexer.hpp"
+using namespace xsk::arc;
+xsk::arc::t6::parser::symbol_type T6lex(xsk::arc::t6::lexer& lexer);
 
 #line 47 "parser.cpp"
 
@@ -3845,80 +3845,86 @@ namespace xsk { namespace arc { namespace t6 {
 #line 3846 "parser.cpp"
     break;
 
-  case 254: // expr_path: "identifier"
+  case 254: // expr_path: "path" "/" "identifier"
 #line 971 "parser.ypp"
-        { yylhs.value.as < ast::expr_path::ptr > () = std::make_unique<ast::expr_path>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+        { yylhs.value.as < ast::expr_path::ptr > () = std::make_unique<ast::expr_path>(yylhs.location, yystack_[2].value.as < std::string > () + "/" + yystack_[0].value.as < std::string > ()); }
 #line 3852 "parser.cpp"
     break;
 
-  case 255: // expr_path: "path"
+  case 255: // expr_path: "identifier"
 #line 973 "parser.ypp"
         { yylhs.value.as < ast::expr_path::ptr > () = std::make_unique<ast::expr_path>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3858 "parser.cpp"
     break;
 
-  case 256: // expr_istring: "localized string"
-#line 978 "parser.ypp"
-        { yylhs.value.as < ast::expr_istring::ptr > () = std::make_unique<ast::expr_istring>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+  case 256: // expr_path: "path"
+#line 975 "parser.ypp"
+        { yylhs.value.as < ast::expr_path::ptr > () = std::make_unique<ast::expr_path>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3864 "parser.cpp"
     break;
 
-  case 257: // expr_string: "string literal"
-#line 983 "parser.ypp"
-        { yylhs.value.as < ast::expr_string::ptr > () = std::make_unique<ast::expr_string>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+  case 257: // expr_istring: "localized string"
+#line 980 "parser.ypp"
+        { yylhs.value.as < ast::expr_istring::ptr > () = std::make_unique<ast::expr_istring>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3870 "parser.cpp"
     break;
 
-  case 258: // expr_vector: "(" expr "," expr "," expr ")"
-#line 988 "parser.ypp"
-        { yylhs.value.as < ast::expr_vector::ptr > () = std::make_unique<ast::expr_vector>(yylhs.location, std::move(yystack_[5].value.as < ast::expr > ()), std::move(yystack_[3].value.as < ast::expr > ()), std::move(yystack_[1].value.as < ast::expr > ())); }
+  case 258: // expr_string: "string literal"
+#line 985 "parser.ypp"
+        { yylhs.value.as < ast::expr_string::ptr > () = std::make_unique<ast::expr_string>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3876 "parser.cpp"
     break;
 
-  case 259: // expr_hash: "hash"
-#line 993 "parser.ypp"
-        { yylhs.value.as < ast::expr_hash::ptr > () = std::make_unique<ast::expr_hash>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+  case 259: // expr_vector: "(" expr "," expr "," expr ")"
+#line 990 "parser.ypp"
+        { yylhs.value.as < ast::expr_vector::ptr > () = std::make_unique<ast::expr_vector>(yylhs.location, std::move(yystack_[5].value.as < ast::expr > ()), std::move(yystack_[3].value.as < ast::expr > ()), std::move(yystack_[1].value.as < ast::expr > ())); }
 #line 3882 "parser.cpp"
     break;
 
-  case 260: // expr_float: "-" "float"
-#line 998 "parser.ypp"
-        { yylhs.value.as < ast::expr_float::ptr > () = std::make_unique<ast::expr_float>(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
+  case 260: // expr_hash: "hash"
+#line 995 "parser.ypp"
+        { yylhs.value.as < ast::expr_hash::ptr > () = std::make_unique<ast::expr_hash>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3888 "parser.cpp"
     break;
 
-  case 261: // expr_float: "float"
+  case 261: // expr_float: "-" "float"
 #line 1000 "parser.ypp"
-        { yylhs.value.as < ast::expr_float::ptr > () = std::make_unique<ast::expr_float>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+        { yylhs.value.as < ast::expr_float::ptr > () = std::make_unique<ast::expr_float>(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
 #line 3894 "parser.cpp"
     break;
 
-  case 262: // expr_integer: "-" "integer"
-#line 1005 "parser.ypp"
-        { yylhs.value.as < ast::expr_integer::ptr > () = std::make_unique<ast::expr_integer>(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
+  case 262: // expr_float: "float"
+#line 1002 "parser.ypp"
+        { yylhs.value.as < ast::expr_float::ptr > () = std::make_unique<ast::expr_float>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3900 "parser.cpp"
     break;
 
-  case 263: // expr_integer: "integer"
+  case 263: // expr_integer: "-" "integer"
 #line 1007 "parser.ypp"
-        { yylhs.value.as < ast::expr_integer::ptr > () = std::make_unique<ast::expr_integer>(yylhs.location, yystack_[0].value.as < std::string > ()); }
+        { yylhs.value.as < ast::expr_integer::ptr > () = std::make_unique<ast::expr_integer>(yylhs.location, "-" + yystack_[0].value.as < std::string > ()); }
 #line 3906 "parser.cpp"
     break;
 
-  case 264: // expr_false: "false"
-#line 1012 "parser.ypp"
-        { yylhs.value.as < ast::expr_false::ptr > () = std::make_unique<ast::expr_false>(yylhs.location); }
+  case 264: // expr_integer: "integer"
+#line 1009 "parser.ypp"
+        { yylhs.value.as < ast::expr_integer::ptr > () = std::make_unique<ast::expr_integer>(yylhs.location, yystack_[0].value.as < std::string > ()); }
 #line 3912 "parser.cpp"
     break;
 
-  case 265: // expr_true: "true"
-#line 1017 "parser.ypp"
-        { yylhs.value.as < ast::expr_true::ptr > () = std::make_unique<ast::expr_true>(yylhs.location); }
+  case 265: // expr_false: "false"
+#line 1014 "parser.ypp"
+        { yylhs.value.as < ast::expr_false::ptr > () = std::make_unique<ast::expr_false>(yylhs.location); }
 #line 3918 "parser.cpp"
     break;
 
+  case 266: // expr_true: "true"
+#line 1019 "parser.ypp"
+        { yylhs.value.as < ast::expr_true::ptr > () = std::make_unique<ast::expr_true>(yylhs.location); }
+#line 3924 "parser.cpp"
+    break;
 
-#line 3922 "parser.cpp"
+
+#line 3928 "parser.cpp"
 
             default:
               break;
@@ -4415,737 +4421,743 @@ namespace xsk { namespace arc { namespace t6 {
   }
 
 
-  const short parser::yypact_ninf_ = -424;
+  const short parser::yypact_ninf_ = -450;
 
-  const short parser::yytable_ninf_ = -255;
+  const short parser::yytable_ninf_ = -256;
 
   const short
   parser::yypact_[] =
   {
-      15,  -424,  -424,   -93,   -93,   -45,   -43,   -43,   -43,  -424,
-    -424,    43,    15,  -424,  -424,  -424,  -424,  -424,   -35,  -424,
-    -424,   -24,     1,   -33,    13,    32,    39,  -424,  -424,  -424,
-    -424,   -43,  -424,  -424,  -424,    34,   -43,   -43,   -43,   -32,
-    -424,    23,    33,    -9,    -7,    -5,    51,   -43,  1509,  -424,
-      51,    51,    51,   880,  -424,  -424,    23,  -424,    12,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,    46,    60,    63,    64,
-      70,    81,    87,    89,    95,    99,   108,   111,   115,   116,
-     118,   122,   130,   131,   135,  1509,   -34,   -43,  1509,  1509,
-     716,    91,   132,  -424,  -424,  -424,  -424,  3447,  -424,  -424,
-    -424,  -424,  -424,  -424,    20,    37,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,   138,  -424,  -424,  -424,  -424,  -424,
-     140,   141,   144,   145,   150,   156,  -424,  -424,   105,   163,
-    -424,  -424,   248,  -424,  -424,   344,   392,   450,   553,  -424,
-    -424,    47,   157,  -424,  -424,  -424,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  1690,  1509,   151,   166,  1880,   168,
-     171,   172,   173,   -62,   160,   164,   167,  1347,   179,   181,
-     -43,  -424,   178,   819,   819,  -424,  -424,  1238,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,   175,   201,   202,   203,   204,   138,   140,
-     141,   144,   145,   150,   156,  -424,  -424,  1788,  -424,  -424,
-    -424,  -424,   183,   180,   211,   216,   209,  1509,  1509,  1509,
-    1509,  1509,  1509,  1509,  1509,  1509,  1509,   217,  1509,  1509,
-    1509,  1509,  1509,  1509,  1509,  1509,  1766,  1509,  -424,  -424,
-    -424,  -424,  1509,  -424,  -424,  -424,  -424,   105,   163,  -424,
-     565,    47,  -424,  1509,  1509,  1509,  1509,  1509,  1509,  1509,
-    1509,  1509,  1509,  1509,  1509,  1509,  1509,  1509,  1509,  1509,
-    1509,  1509,  1509,  1509,  1509,  1509,  1509,  1509,  1509,  1590,
-     -27,  -424,  -424,   183,  1509,   -43,  -424,  -424,  1753,  3364,
-    -424,  1509,   262,  1509,   309,   -43,  1509,   176,   213,   220,
-    -424,  -424,  -424,  -424,  3399,  1509,  1509,   206,   565,   565,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,   230,   233,   236,
-     237,   195,  -424,  -424,  1509,  1509,  1509,  1509,  1509,  1509,
-    1509,  1509,  1509,  1509,  1509,   -43,  1509,  1509,   -43,  3215,
-    2012,  2046,  2080,  2114,  2148,  2182,  2216,  2250,  2284,  -424,
-    2318,  2352,  2386,  2420,  2454,  2488,  3254,  2522,  -424,  1509,
-    1424,  2556,  3329,   153,   153,   982,  1107,   949,   949,   161,
-     161,   161,   161,  1247,  1259,  1140,    35,    35,  -424,  -424,
-    -424,  1505,  1586,  2936,  2976,  3016,  3056,  3096,  1428,  3136,
-    -424,  -424,  -424,  3447,     3,  -424,   247,  -424,  -424,  -424,
-    2590,   254,  2624,   250,  -424,  -424,  -424,   910,   -28,  2658,
-    -424,  -424,  -424,     9,    27,  1509,  1509,  1509,  1509,  1509,
-    3447,  3447,  3447,  3447,  3447,  3447,  3447,  3447,  3447,  3447,
-    3447,   247,  3176,    28,   263,  1509,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,
-    -424,  1509,  -424,  3293,   261,  1509,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  1509,  1509,  1880,  1509,  1880,
-    1509,  1509,   -43,    51,   257,   258,  3434,  2692,  1890,  1934,
-    1978,   264,  -424,  1509,  2726,  2760,  1509,   270,  3447,  3447,
-      44,   314,  2794,  -424,  3447,   267,  2828,   317,  -424,  -424,
-    -424,  -424,   271,   272,  1509,   280,  1509,   282,  1509,   295,
-      84,  -424,  -424,  2862,  1509,  -424,  1880,   287,   309,  1880,
-    1509,  -424,  -424,   285,   297,  -424,   298,  -424,   299,  1509,
-    -424,  -424,    90,  -424,  -424,   307,  -424,  2896,   300,   302,
-     304,    96,  -424,  1880,  1880,  -424,  -424,  -424,  -424,  -424,
-    -424
+      33,  -450,  -450,   -82,   -82,   -68,   -28,   -28,   -28,  -450,
+    -450,    18,    33,  -450,  -450,  -450,  -450,  -450,   -40,   -86,
+    -450,   -27,   -23,   -77,   -11,     3,    27,  -450,  -450,  -450,
+    -450,   -28,   -13,  -450,  -450,  -450,    46,   -28,   -28,   -28,
+     -35,  -450,    26,  -450,    24,     4,     5,     6,    51,   -28,
+    1421,  -450,    51,    51,    51,   928,  -450,  -450,    26,  -450,
+     -10,  -450,  -450,  -450,  -450,  -450,  -450,  -450,    58,    60,
+      62,    63,    65,    68,    71,    72,    82,    83,    85,    91,
+      93,    95,   101,   104,   110,   111,   113,  1421,    19,   -28,
+    1421,  1421,  1541,    74,    48,  -450,  -450,  -450,  -450,  3449,
+    -450,  -450,  -450,  -450,  -450,  -450,    21,   137,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,   121,  -450,  -450,  -450,
+    -450,  -450,   123,   124,   125,   126,   128,   139,  -450,  -450,
+     258,   295,  -450,  -450,   310,  -450,  -450,   312,   319,   399,
+     519,  -450,  -450,   -16,   106,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  1602,  1421,   114,   145,
+    1727,   148,   151,   152,   153,   -89,   146,   154,   156,   812,
+     163,   167,   -28,  -450,   164,  1757,  1757,  -450,  -450,  1231,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,   161,   168,   170,   176,   177,
+     121,   123,   124,   125,   126,   128,   139,  -450,  -450,   992,
+    -450,  -450,  -450,  -450,   172,   165,   173,   174,   182,  1421,
+    1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,   192,
+    1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1768,  1421,
+    -450,  -450,  -450,  -450,  1421,  -450,  -450,  -450,  -450,   258,
+     295,  -450,   530,   -16,  -450,  1421,  1421,  1421,  1421,  1421,
+    1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,
+    1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,  1421,
+    1421,  1502,   -25,  -450,  -450,   172,  1421,   -28,  -450,  -450,
+    1665,  3366,  -450,  1421,   238,  1421,  1261,   -28,  1421,   147,
+     194,   197,  -450,  -450,  -450,  -450,  3401,  1421,  1421,   183,
+     530,   530,  -450,  -450,  -450,  -450,  -450,  -450,  -450,   210,
+     211,   212,   213,   171,  -450,  -450,  1421,  1421,  1421,  1421,
+    1421,  1421,  1421,  1421,  1421,  1421,  1421,   -28,  1421,  1421,
+     -28,  3217,  1934,  1968,  2002,  2036,  2070,  2104,  2138,  2172,
+    2206,  -450,  2240,  2274,  2308,  2342,  2376,  2410,  3256,  2444,
+    -450,  1421,  1417,  2478,  3331,    94,    94,  1100,  3480,   824,
+     824,   510,   510,   510,   510,  3490,  3521,  1133,    55,    55,
+    -450,  -450,  -450,  2858,  2898,  2938,  2978,  3018,  3058,  3098,
+    1340,  3138,  -450,  -450,  -450,  3449,     8,  -450,   219,  -450,
+    -450,  -450,  2512,   220,  2546,   214,  -450,  -450,  -450,   678,
+      -8,  2580,  -450,  -450,  -450,    14,    25,  1421,  1421,  1421,
+    1421,  1421,  3449,  3449,  3449,  3449,  3449,  3449,  3449,  3449,
+    3449,  3449,  3449,   219,  3178,    36,   221,  1421,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  1421,  -450,  3295,   217,  1421,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  1421,  1421,  1727,
+    1421,  1727,  1421,  1421,   -28,    51,   216,   218,  3436,  2614,
+    1812,  1856,  1900,   226,  -450,  1421,  2648,  2682,  1421,   223,
+    3449,  3449,    39,   275,  2716,  -450,  3449,   224,  2750,   273,
+    -450,  -450,  -450,  -450,   229,   231,  1421,   233,  1421,   234,
+    1421,   245,    42,  -450,  -450,  2784,  1421,  -450,  1727,   239,
+    1261,  1727,  1421,  -450,  -450,   248,   255,  -450,   256,  -450,
+     262,  1421,  -450,  -450,    43,  -450,  -450,   263,  -450,  2818,
+     259,   272,   274,    45,  -450,  1727,  1727,  -450,  -450,  -450,
+    -450,  -450,  -450
   };
 
   const short
   parser::yydefact_[] =
   {
        3,    12,    13,     0,     0,     0,     0,     0,     0,   253,
-     252,     0,     2,     7,     8,     9,    14,    15,     0,   255,
-     254,     0,     0,     0,     0,     0,     0,     1,     4,     5,
-       6,   196,    10,    11,   257,     0,   196,   196,   196,     0,
-     194,   195,     0,     0,     0,     0,     0,     0,     0,    16,
-       0,     0,     0,     0,    17,   192,   193,   250,     0,   265,
-     264,   244,   245,   246,   247,   248,     0,     0,     0,     0,
+     252,     0,     2,     7,     8,     9,    14,    15,     0,   256,
+     255,     0,     0,     0,     0,     0,     0,     1,     4,     5,
+       6,   196,     0,    10,    11,   258,     0,   196,   196,   196,
+       0,   194,   195,   254,     0,     0,     0,     0,     0,     0,
+       0,    16,     0,     0,     0,     0,    17,   192,   193,   250,
+       0,   266,   265,   244,   245,   246,   247,   248,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   252,   256,   259,   261,   263,   197,    91,    92,
-      93,   130,   131,   132,   133,   134,   182,   183,   135,   136,
-     137,   138,   139,   140,   141,   142,   143,   144,   145,   146,
-     147,   148,   149,   150,   151,   152,   153,   154,   155,   156,
-     157,   158,     0,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,     0,   168,   169,   170,   171,   172,   173,   174,
-     175,    18,    19,    20,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   252,   257,   260,   262,   264,   197,
+      91,    92,    93,   130,   131,   132,   133,   134,   182,   183,
+     135,   136,   137,   138,   139,   140,   141,   142,   143,   144,
+     145,   146,   147,   148,   149,   150,   151,   152,   153,   154,
+     155,   156,   157,   158,     0,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,     0,   168,   169,   170,   171,   172,
+     173,   174,   175,    18,    19,    20,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    54,     0,     0,     0,    45,    50,     0,    46,    21,
-      22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
-      32,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      42,    43,    44,     0,     0,     0,   234,   235,     0,     0,
-       0,     0,     0,     0,     0,   236,   237,     0,   238,   239,
-     240,   241,   242,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,   243,   221,
-     181,   176,     0,   260,   262,   234,   235,   179,   180,   178,
-       0,   177,   249,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    54,     0,     0,     0,    45,    50,     0,
+      46,    21,    22,    23,    24,    25,    26,    27,    28,    29,
+      30,    31,    32,    33,    34,    35,    36,    37,    38,    39,
+      40,    41,    42,    43,    44,     0,     0,     0,   234,   235,
+       0,     0,     0,     0,     0,     0,     0,   236,   237,     0,
+     238,   239,   240,   241,   242,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   184,   185,     0,   199,     0,    52,    48,     0,     0,
-      73,     0,     0,     0,    58,     0,     0,     0,     0,     0,
-      84,    85,    86,    88,     0,   199,   199,     0,   107,   109,
-      53,    49,    62,    63,    64,    59,    60,     0,     0,     0,
-       0,     0,   108,   110,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   199,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   212,
-       0,     0,     0,     0,     0,     0,     0,     0,   233,     0,
-       0,     0,     0,   123,   124,   112,   113,   114,   115,   116,
-     117,   118,   119,   120,   121,   122,   125,   126,   127,   128,
-     129,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     232,   251,   231,   201,     0,   198,   222,    51,    47,    68,
-       0,     0,     0,     0,    55,    56,    57,     0,     0,     0,
-      83,    82,    87,     0,     0,     0,     0,     0,     0,     0,
-      96,   102,   103,   104,   105,   106,    97,    98,    99,   101,
-     100,     0,     0,     0,     0,     0,   203,   204,   205,   206,
-     207,   208,   209,   210,   211,   213,   214,   215,   216,   217,
-     218,     0,   220,     0,     0,     0,   224,   225,   226,   227,
-     228,   229,   230,   223,   186,     0,   199,     0,     0,     0,
-      95,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   188,   199,     0,     0,     0,     0,   111,   200,
-       0,    74,     0,    76,    94,     0,     0,     0,    81,    89,
-      90,    61,     0,     0,   199,     0,   199,     0,   199,     0,
-       0,   202,   219,     0,   199,   187,     0,     0,    58,     0,
-       0,    65,    67,     0,   198,    70,   198,    72,   198,   199,
-     189,   258,     0,    75,    77,     0,    79,     0,     0,     0,
-       0,     0,   190,     0,     0,    66,    69,    71,   191,    78,
-      80
+     243,   221,   181,   176,     0,   261,   263,   234,   235,   179,
+     180,   178,     0,   177,   249,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   184,   185,     0,   199,     0,    52,    48,
+       0,     0,    73,     0,     0,     0,    58,     0,     0,     0,
+       0,     0,    84,    85,    86,    88,     0,   199,   199,     0,
+     107,   109,    53,    49,    62,    63,    64,    59,    60,     0,
+       0,     0,     0,     0,   108,   110,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   199,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   212,     0,     0,     0,     0,     0,     0,     0,     0,
+     233,     0,     0,     0,     0,   123,   124,   112,   113,   114,
+     115,   116,   117,   118,   119,   120,   121,   122,   125,   126,
+     127,   128,   129,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,   232,   251,   231,   201,     0,   198,   222,    51,
+      47,    68,     0,     0,     0,     0,    55,    56,    57,     0,
+       0,     0,    83,    82,    87,     0,     0,     0,     0,     0,
+       0,     0,    96,   102,   103,   104,   105,   106,    97,    98,
+      99,   101,   100,     0,     0,     0,     0,     0,   203,   204,
+     205,   206,   207,   208,   209,   210,   211,   213,   214,   215,
+     216,   217,   218,     0,   220,     0,     0,     0,   224,   225,
+     226,   227,   228,   229,   230,   223,   186,     0,   199,     0,
+       0,     0,    95,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   188,   199,     0,     0,     0,     0,
+     111,   200,     0,    74,     0,    76,    94,     0,     0,     0,
+      81,    89,    90,    61,     0,     0,   199,     0,   199,     0,
+     199,     0,     0,   202,   219,     0,   199,   187,     0,     0,
+      58,     0,     0,    65,    67,     0,   198,    70,   198,    72,
+     198,   199,   189,   259,     0,    75,    77,     0,    79,     0,
+       0,     0,     0,     0,   190,     0,     0,    66,    69,    71,
+     191,    78,    80
   };
 
   const short
   parser::yypgoto_[] =
   {
-    -424,  -424,  -424,   367,   374,   375,  -424,  -424,   -82,   219,
-    -424,  -424,  -424,   -31,  -140,  -424,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,
-    -424,  -424,  -424,  -424,  -424,  -424,  -424,  -424,   901,  -424,
-    -303,  -295,  -294,  -424,  -424,  -424,  -424,  -424,  -424,   -48,
-     -36,  -121,  -116,    14,   343,  -270,  -423,  -424,  -424,  -424,
-    -424,  -424,  -424,    17,  -424,  -424,  -424,  -424,  -424,    22,
-      55,   103,   136,   158,   169,  -424,  -424,   281,   291,  -424,
-     303,   346,  -424,  -424,   445,   551,   559,   573,  -424,  -424,
-    -424,     0,    10,  -424,   -20,  -424,  -424,  -424,   231,  -424,
-    -424
+    -450,  -450,  -450,   316,   330,   331,  -450,  -450,   -73,   179,
+    -450,  -450,  -450,   -43,  -169,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,
+    -450,  -450,  -450,  -450,  -450,  -450,  -450,  -450,   892,  -450,
+    -302,  -291,  -290,  -450,  -450,  -450,  -450,  -450,  -450,   -36,
+     -29,  -133,  -111,   120,   317,  -275,  -449,  -450,  -450,  -450,
+    -450,  -450,  -450,    17,  -450,  -450,  -450,  -450,  -450,    56,
+      70,    99,   109,   162,   169,  -450,  -450,   203,   257,  -450,
+     276,   291,  -450,  -450,   357,   491,   527,   589,  -450,  -450,
+    -450,     0,    10,  -450,   -20,  -450,  -450,  -450,   200,  -450,
+    -450
   };
 
   const short
   parser::yydefgoto_[] =
   {
-       0,    11,    12,    13,    14,    15,    16,    17,   175,   176,
-     298,   177,   178,   179,   413,   180,   181,   182,   183,   184,
-     185,   186,   187,   188,   189,   190,   191,   192,   193,   194,
-     195,   196,   197,   198,   199,   200,   201,   202,   403,   505,
-     203,   204,   205,    98,    99,   100,   101,   102,   103,   104,
-     105,   106,   107,    39,    40,   533,   405,   108,   109,   110,
-     111,   112,   113,   114,   115,   116,   117,   118,   119,   120,
-     121,   122,   123,   124,   125,   126,   127,   128,   129,   130,
-     131,   132,   133,   134,   135,   136,   137,   138,   139,   140,
-     402,   141,   142,   143,   144,   145,   146,   147,   148,   149,
-     150
+       0,    11,    12,    13,    14,    15,    16,    17,   177,   178,
+     300,   179,   180,   181,   415,   182,   183,   184,   185,   186,
+     187,   188,   189,   190,   191,   192,   193,   194,   195,   196,
+     197,   198,   199,   200,   201,   202,   203,   204,   405,   507,
+     205,   206,   207,   100,   101,   102,   103,   104,   105,   106,
+     107,   108,   109,    40,    41,   535,   407,   110,   111,   112,
+     113,   114,   115,   116,   117,   118,   119,   120,   121,   122,
+     123,   124,   125,   126,   127,   128,   129,   130,   131,   132,
+     133,   134,   135,   136,   137,   138,   139,   140,   141,   142,
+     404,   143,   144,   145,   146,   147,   148,   149,   150,   151,
+     152
   };
 
   const short
   parser::yytable_[] =
   {
-      18,   414,     9,    35,   481,   206,    24,    25,    26,   415,
-     416,   291,    18,    21,    22,    54,   292,   207,   400,   151,
-     152,   153,    19,    20,   404,    23,     1,     2,     3,     4,
-       5,    41,     6,     7,     8,    31,    41,    41,    41,    46,
-     247,   248,   255,    27,    47,   423,   424,    56,   482,   307,
-      43,    44,    45,   222,   256,    34,    32,     9,   225,    96,
-       9,  -234,    50,   223,    51,  -234,    52,    47,   226,    47,
-     208,    47,   297,    10,   474,   209,   302,   443,  -235,   475,
-     484,    33,  -235,    36,    34,   475,   224,   249,  -242,   401,
-     261,   534,  -242,   536,  -234,   538,   291,  -234,   485,   492,
-     223,   292,    37,   475,   475,    42,   206,   208,   210,    38,
-     206,  -235,   209,    49,  -235,   525,   227,   294,   207,    48,
-     475,  -242,   207,    53,  -242,   255,   255,    19,    92,   206,
-     228,    10,   293,   229,   230,  -234,  -234,   256,   256,   291,
-     231,   207,   223,   308,   292,   210,  -236,   279,   280,   281,
-    -236,   232,  -235,  -235,   222,   540,   211,   233,   222,   234,
-     475,   552,  -242,  -242,   223,   235,   475,   558,   223,   236,
-     317,   208,   475,   222,   222,   208,   209,   222,   237,  -236,
-     209,   238,  -236,   223,   223,   239,   240,   223,   241,   212,
-     208,   208,   242,   211,   208,   209,   209,   291,   291,   209,
-     243,   244,   292,   292,  -237,   245,   500,   262,  -237,   210,
-    -254,   213,   282,   210,   283,   284,   408,   293,   285,   286,
-    -236,  -236,   214,   520,   287,   414,   212,   223,   210,   210,
-     288,   300,   210,   415,   416,   295,   301,  -237,   303,   310,
-    -237,   304,   305,   306,   311,   264,   265,   312,   213,   315,
-     206,   316,   247,   294,   542,   322,   255,   211,   345,   214,
-     293,   211,   207,   277,   278,   279,   280,   281,   256,   551,
-     223,   277,   278,   279,   280,   281,   211,   211,  -237,  -237,
-     211,   323,   324,   325,   326,   346,   347,   348,   359,    58,
-     212,   411,   420,     9,   212,   406,   291,   254,   222,   421,
-     426,   292,   425,   427,   222,   418,   428,   429,   223,   212,
-     212,   401,   213,   212,   223,   208,   213,   476,   293,   293,
-     209,   208,   289,   214,   478,   290,   209,   214,   223,   223,
-     480,   213,   213,   493,   215,   213,   497,   509,   510,   519,
-     524,   526,   214,   214,   216,   441,   214,   528,   444,   530,
-      58,   531,   532,   210,     9,    62,    63,    64,    65,   210,
-     535,   475,   537,    19,    92,   539,    72,   544,   548,   549,
-     550,   257,    78,    79,    80,    81,    82,    83,   553,    28,
-     555,   258,   556,   172,   557,  -238,    29,    30,   545,  -238,
-      55,   173,   174,   259,   309,   501,   321,   503,     0,   217,
-       0,   211,     0,     0,     0,     0,     0,   211,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   293,  -238,     0,
-       0,  -238,     0,     0,    19,    92,     0,   223,     0,   206,
-       0,   206,     0,  -239,   212,   215,   260,  -239,     0,   215,
-     212,   207,     0,   207,   543,   216,     0,   546,     0,   216,
-       0,     0,   508,     0,   215,   215,   213,     0,   215,  -238,
-    -238,     0,   213,     0,   216,   216,  -239,   214,   216,  -239,
-       0,   559,   560,   214,     0,     0,     0,   222,   206,   222,
-     255,   206,   507,     0,     0,     0,     0,   223,     0,   223,
-     207,  -240,   256,   207,   208,  -240,   208,     0,   218,   209,
-     217,   209,     0,     0,   217,   206,   206,  -239,  -239,     0,
-       0,     0,     0,     0,     0,     0,     0,   207,   207,   318,
-     319,     0,     0,   217,  -240,     0,   222,  -240,   222,   222,
-       0,     0,   210,     0,   210,   218,   223,     0,   223,   223,
-       0,     0,     0,   208,     0,   208,   208,     0,   209,     0,
-     209,   209,     0,   222,   222,     0,     0,     0,     0,     0,
-       0,     0,     0,   223,   223,  -240,  -240,     0,     0,     0,
-     208,   208,     0,     0,     0,   209,   209,     0,     0,   215,
-     211,   210,   211,   210,   210,   215,     0,     0,     0,   216,
-       0,     0,     0,     0,  -241,   216,     0,     0,  -241,   218,
-       0,     0,     0,   218,   219,     0,    58,     0,   210,   210,
-       9,     0,   220,   212,     0,   212,     0,     0,   218,   218,
-       0,     0,   218,     0,     0,     0,   221,  -241,     0,   211,
-    -241,   211,   211,     0,     0,   213,     0,   213,     0,   289,
-       0,   219,   331,     0,   217,     0,   214,     0,   214,   220,
-     417,     0,     0,     0,     0,     0,   211,   211,     0,     0,
-       0,     0,   212,   221,   212,   212,     0,     0,  -241,  -241,
+      18,   293,    23,    36,   416,    56,    24,    25,    26,   153,
+     154,   155,    18,    21,    22,   417,   418,     9,    27,   208,
+     402,   406,   309,   294,   483,  -242,   209,    32,    35,  -242,
+      31,    42,    98,    19,    20,     9,    48,    42,    42,    42,
+      35,    49,   425,   426,     1,     2,     3,     4,     5,    58,
+       6,     7,     8,    33,   296,   224,   257,    34,  -242,    37,
+     227,  -242,  -234,   258,   226,   225,  -234,   536,   484,   538,
+     228,   540,   210,    38,   445,    52,    53,    54,     9,   476,
+      49,    49,    49,   299,   477,   486,   293,   304,    10,   251,
+     477,   403,   263,   249,   250,  -234,   487,    39,  -234,  -242,
+    -242,   477,   225,    43,    51,    19,    94,   494,   294,   210,
+     527,   211,   477,   542,   554,   477,   560,    44,   477,   477,
+     208,   477,    50,    55,   208,   212,  -255,   209,   229,   293,
+     230,   209,   231,   232,   295,   233,  -234,  -234,   234,   257,
+     257,   235,   236,   208,   225,   310,   258,   258,   211,    10,
+     209,   294,   237,   238,   213,   239,   224,    45,    46,    47,
+     224,   240,   212,   241,   214,   242,   225,   281,   282,   283,
+     225,   243,   319,   210,   244,   224,   224,   210,  -235,   224,
+     245,   246,  -235,   247,   297,   225,   225,   293,   293,   225,
+     264,   213,   210,   210,   302,   284,   210,   285,   286,   287,
+     288,   214,   289,   502,   279,   280,   281,   282,   283,   294,
+     294,  -235,   211,   290,  -235,   303,   211,   215,   305,   295,
+     522,   306,   307,   308,   216,   312,   212,   410,   416,   225,
+     212,   211,   211,   317,   313,   211,   314,   318,   249,   417,
+     418,   324,   296,   347,   349,   212,   212,   348,   325,   212,
+     326,   544,  -235,  -235,   215,   213,   327,   328,   217,   213,
+     350,   216,   295,   361,   208,   214,   553,   413,   256,   214,
+     257,   209,   225,   422,   213,   213,   423,   258,   213,   427,
+     428,   429,   430,   431,   214,   214,   293,   403,   214,   478,
+     480,   495,   499,   526,   482,   259,   511,   408,   512,  -236,
+     224,   521,   528,  -236,   530,   532,   224,   420,   294,   533,
+     225,   534,   218,   537,   539,   541,   225,   210,   215,   546,
+     295,   295,   215,   210,   477,   216,   550,   551,    28,   216,
+     225,   225,  -236,   552,   555,  -236,  -237,   215,   215,   557,
+    -237,   215,    29,    30,   216,   216,   219,   443,   216,   260,
+     446,    60,   558,  -238,   559,     9,   211,  -238,   323,   217,
+    -239,   547,   211,   217,  -239,   311,    57,     0,   261,  -237,
+     212,     0,  -237,  -236,  -236,     0,   212,     0,   217,   217,
+       0,     0,   217,   262,   291,     0,  -238,   292,     0,  -238,
+       0,     0,     0,  -239,     0,     0,  -239,     0,     0,   213,
+       0,     0,     0,     0,     0,   213,   503,     0,   505,   214,
+    -237,  -237,   220,   218,     0,   214,     0,   218,     0,   295,
+       0,     0,     0,     0,     0,    19,    94,  -238,  -238,   225,
+       0,     0,   218,   218,  -239,  -239,   218,     0,     0,     0,
+    -240,     0,   510,   208,  -240,   208,     0,   219,     0,   220,
+     209,   219,   209,     0,     0,   545,     0,     0,   548,     0,
+       0,     0,   215,     0,     0,     0,   320,   321,   215,   216,
+     219,     0,     0,  -240,     0,   216,  -240,     0,     0,   224,
+       0,   224,   561,   562,   509,     0,     0,     0,     0,   225,
+       0,   225,   208,     0,   257,   208,   210,     0,   210,   209,
+       0,   258,   209,   217,     0,     0,     0,     0,     0,   217,
+       0,     0,     0,   220,  -240,  -240,     0,   220,     0,   208,
+     208,     0,     0,     0,     0,     0,   209,   209,   224,     0,
+     224,   224,   220,   220,     0,   211,   220,   211,   225,     0,
+     225,   225,     0,     0,     0,   210,   221,   210,   210,   212,
+       0,   212,     0,     0,     0,   224,   224,   218,     0,     0,
+    -241,     0,     0,   218,  -241,   225,   225,     0,     0,     0,
+       0,    60,   210,   210,     0,     9,     0,     0,   213,     0,
+     213,     0,   222,   221,   211,     0,   211,   211,   214,     0,
+     214,   219,     0,  -241,   266,   267,  -241,   419,   212,     0,
+     212,   212,     0,     0,   291,     0,     0,   333,     0,     0,
+       0,   211,   211,     0,     0,     0,     0,     0,     0,   222,
+     279,   280,   281,   282,   283,   212,   212,   213,     0,   213,
+     213,     0,     0,     0,  -241,  -241,     0,   214,     0,   214,
+     214,   215,     0,   215,   223,    19,    94,   221,   216,     0,
+     216,   221,     0,     0,   213,   213,     0,   220,     0,     0,
+       0,     0,     0,   220,   214,   214,   221,   221,     0,     0,
+     221,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,   223,   217,   222,   217,     0,     0,   222,     0,     0,
+     215,     0,   215,   215,     0,     0,     0,   216,     0,   216,
+     216,     0,   222,   222,     0,     0,   222,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   215,   215,    60,
+       0,     0,     0,     9,   216,   216,     0,     0,     0,     0,
+       0,   217,     0,   217,   217,     0,   218,     0,   218,     0,
+       0,     0,     0,     0,     0,   223,     0,     0,     0,   223,
+       0,     0,   291,     0,     0,   333,     0,     0,   217,   217,
+     334,   335,     0,     0,   223,   223,     0,     0,   223,     0,
+     219,     0,   219,     0,   336,   337,   338,   339,   340,   341,
+     342,   343,   344,   345,   346,   218,     0,   218,   218,     0,
+       0,   221,     0,    19,    94,     0,     0,   221,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-      19,    92,     0,     0,   213,     0,   213,   213,     0,   212,
-     212,     0,     0,     0,     0,   214,     0,   214,   214,     0,
-       0,     0,     0,     0,     0,   219,     0,     0,     0,   219,
-       0,   213,   213,   220,     0,     0,     0,   220,     0,     0,
-       0,     0,   214,   214,   219,   219,     0,   221,   219,     0,
-       0,   221,   220,   220,     0,     0,   220,     0,     0,     0,
-       0,     0,     0,   218,     0,     0,   221,   221,     0,   218,
-     221,     0,     0,     0,     0,     0,     0,    58,   215,     0,
-     215,     9,    62,    63,    64,    65,     0,     0,   216,     0,
-     216,     0,     0,    72,     0,     0,     0,     0,     0,    78,
-      79,    80,    81,    82,    83,     0,   252,     0,     0,     0,
-     172,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   215,     0,   215,
-     215,     0,     0,     0,     0,     0,     0,   216,     0,   216,
-     216,     0,     0,   217,     0,   217,     0,     0,     0,     0,
-       0,    19,    92,     0,   215,   215,   253,   254,     0,     0,
-       0,     0,     0,     0,   216,   216,     0,     0,     0,   219,
-       0,     0,     0,     0,     0,   219,     0,   220,     0,     0,
-      58,     0,     0,   220,     9,    62,    63,    64,    65,     0,
-       0,   221,   217,     0,   417,   217,    72,   221,     0,     0,
-       0,     0,    78,    79,    80,    81,    82,    83,     0,     0,
-       0,   154,     0,   172,     0,     0,     0,     0,     0,   217,
-     217,     0,   155,     0,     0,   156,   157,     0,   158,   159,
-     160,   161,     0,   162,   163,   164,   165,   166,   167,   168,
-     169,    58,   218,     0,   218,     9,    62,    63,    64,    65,
-     170,     0,     0,     0,    19,    92,     0,    72,     0,     0,
-       0,     0,     0,    78,    79,    80,    81,    82,    83,    97,
-       0,    58,    53,   171,   172,     9,     0,     0,     0,     0,
-       0,     0,   173,   174,     0,     0,     0,     0,     0,     0,
-       0,   218,     0,   218,   218,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   289,     0,   246,   331,     0,   250,
-     251,     0,   332,   333,     0,    19,    92,     0,   218,   218,
-       0,     0,     0,     0,     0,     0,   334,   335,   336,   337,
-     338,   339,   340,   341,   342,   343,   344,     0,     0,     0,
-       0,     0,     0,     0,     0,    19,    92,     0,   219,     0,
-     219,     0,     0,   264,   265,     0,   220,     0,   220,   270,
-     271,   272,   273,     0,     0,     0,     0,     0,     0,     0,
-     221,     0,   221,     0,     0,     0,   299,     0,     0,   277,
-     278,   279,   280,   281,     0,     0,   264,   265,   314,   267,
-     268,   269,   270,   271,   272,   273,     0,   219,     0,   219,
-     219,     0,     0,     0,     0,   220,     0,   220,   220,   274,
-     275,   276,   277,   278,   279,   280,   281,     0,     0,   221,
-       0,   221,   221,     0,   219,   219,     0,     0,     0,     0,
-       0,     0,   220,   220,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   221,   221,   349,   350,
-     351,   352,   353,   354,   355,   356,   357,   358,     0,   360,
-     361,   362,   363,   364,   365,   366,   367,     0,   370,     0,
-       0,     0,     0,   371,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,   372,   373,   374,   375,   376,   377,
-     378,   379,   380,   381,   382,   383,   384,   385,   386,   387,
-     388,   389,   390,   391,   392,   393,   394,   395,   396,   397,
-     399,   264,   265,     0,     0,   268,   269,   270,   271,   272,
-     273,     0,   410,     0,   412,     0,     0,   419,     0,     0,
-       0,     0,     0,     0,   274,   275,   276,   277,   278,   279,
-     280,   281,     0,     0,   264,   265,     0,     0,   268,   269,
-     270,   271,   272,   273,     0,   430,   431,   432,   433,   434,
-     435,   436,   437,   438,   439,   440,     0,   442,   275,   154,
-     277,   278,   279,   280,   281,     0,     0,     0,     0,     0,
-     155,     0,     0,   156,   157,     0,   158,   159,   160,   161,
-     463,   162,   163,   164,   165,   166,   167,   168,   169,    58,
-       0,     0,     0,     9,    62,    63,    64,    65,   170,     0,
-       0,     0,     0,     0,     0,    72,     0,     0,     0,   370,
-       0,    78,    79,    80,    81,    82,    83,     0,     0,     0,
-      53,   320,   172,     0,     0,     0,     0,     0,     0,     0,
-     173,   174,     0,     0,     0,     0,   486,   487,   488,   489,
-     490,   264,   265,     0,     0,   268,   269,   270,   271,   272,
-     273,     0,     0,   264,   265,     0,   494,   268,   269,   270,
-     271,   272,   273,    19,    92,   275,   276,   277,   278,   279,
-     280,   281,   495,    57,     0,     0,   498,     0,     0,   277,
-     278,   279,   280,   281,     0,     0,   499,     0,     0,   502,
-       0,   504,   506,     0,     0,     0,     0,     0,    58,    59,
-      60,    61,     9,    62,    63,    64,    65,   523,    66,    67,
-      68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
-      78,    79,    80,    81,    82,    83,    84,    85,     0,     0,
-       0,    86,     0,     0,     0,    87,     0,   313,     0,     0,
-       0,   547,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,    88,    89,     0,    57,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,    90,     0,
-       0,    91,    19,    92,    34,    93,    94,    95,    96,    58,
-      59,    60,    61,     9,    62,    63,    64,    65,     0,    66,
-      67,    68,    69,    70,    71,    72,    73,    74,    75,    76,
-      77,    78,    79,    80,    81,    82,    83,    84,    85,   464,
-       0,     0,   398,   248,     0,   263,    87,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,    88,    89,     0,    57,     0,     0,     0,     0,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,    90,
-       0,     0,    91,    19,    92,    34,    93,    94,    95,    96,
-      58,    59,    60,    61,     9,    62,    63,    64,    65,     0,
-      66,    67,    68,    69,    70,    71,    72,    73,    74,    75,
-      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
-     466,     0,     0,    86,     0,     0,   263,    87,     0,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,     0,
-       0,     0,     0,    88,    89,     0,    57,     0,     0,     0,
-       0,     0,   274,   275,   276,   277,   278,   279,   280,   281,
-      90,     0,     0,    91,    19,    92,    34,    93,    94,    95,
-      96,    58,    59,    60,    61,     9,    62,    63,    64,    65,
-       0,    66,    67,    68,    69,    70,    71,    72,    73,    74,
+       0,     0,   218,   218,     0,     0,     0,     0,     0,   219,
+       0,   419,   219,     0,     0,     0,     0,   222,    59,     0,
+       0,     0,     0,   222,     0,     0,   220,     0,   220,     0,
+       0,     0,     0,     0,     0,     0,   219,   219,     0,     0,
+       0,     0,     0,    60,    61,    62,    63,     9,    64,    65,
+      66,    67,     0,    68,    69,    70,    71,    72,    73,    74,
       75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
-      85,   467,     0,     0,   398,     0,     0,   263,    87,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-       0,     0,     0,     0,    88,    89,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,    90,   296,     0,    91,    19,    92,    34,    93,    94,
-      95,    96,   155,     0,     0,   156,   157,     0,   158,   159,
-     160,   161,     0,   162,   163,   164,   165,   166,   167,   168,
-     169,    58,     0,     0,     0,     9,    62,    63,    64,    65,
-     170,     0,     0,     0,     0,     0,     0,    72,     0,     0,
-       0,     0,     0,    78,    79,    80,    81,    82,    83,     0,
-       0,     0,    53,     0,   172,   407,     0,     0,     0,     0,
-       0,     0,   173,   174,     0,   155,     0,     0,   156,   157,
-       0,   158,   159,   160,   161,     0,   162,   163,   164,   165,
-     166,   167,   168,   169,    58,     0,     0,     0,     9,    62,
-      63,    64,    65,   170,     0,    19,    92,     0,   327,   328,
-      72,   329,   330,     0,     0,     0,    78,    79,    80,    81,
-      82,    83,     0,     0,     0,    53,     0,   172,     0,    58,
-       0,     0,     0,     9,     0,   173,   174,   368,     0,     0,
-       0,     0,   369,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-       0,     0,   289,     0,     0,   331,     0,     0,    19,    92,
-     332,   333,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,     0,     0,     0,   334,   335,   336,   337,   338,   339,
-     340,   341,   342,   343,   344,     0,     0,     0,     0,     0,
-       0,     0,   155,    19,    92,   156,   157,     0,   158,   159,
-     160,   161,     0,   162,   163,   164,   165,   166,   167,   168,
-     169,    58,     0,     0,     0,     9,    62,    63,    64,    65,
-     170,     0,     0,     0,     0,     0,     0,    72,     0,     0,
-       0,     0,     0,    78,    79,    80,    81,    82,    83,     0,
-       0,     0,    53,     0,   172,     0,     0,     0,     0,     0,
-       0,   513,   173,   174,     0,     0,   514,     0,     0,     0,
-       0,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,    19,    92,   274,   275,   276,
-     277,   278,   279,   280,   281,   515,     0,     0,     0,     0,
-     516,     0,     0,     0,     0,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
+      85,    86,    87,     0,     0,   220,    88,   220,   220,   223,
+      89,     0,   315,     0,     0,   223,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,    90,    91,   266,   267,
+       0,     0,   220,   220,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,    92,     0,     0,    93,    19,    94,    35,
+      95,    96,    97,    98,   279,   280,   281,   282,   283,   156,
+       0,     0,    99,     0,     0,     0,     0,     0,     0,     0,
+     157,     0,     0,   158,   159,     0,   160,   161,   162,   163,
+       0,   164,   165,   166,   167,   168,   169,   170,   171,    60,
+     221,     0,   221,     9,    64,    65,    66,    67,   172,   248,
+       0,     0,   252,   253,     0,    74,     0,     0,     0,     0,
+       0,    80,    81,    82,    83,    84,    85,     0,     0,     0,
+      55,   173,   174,     0,     0,     0,   222,     0,   222,     0,
+     175,   176,   329,   330,     0,   331,   332,     0,     0,   221,
+       0,   221,   221,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,    60,     0,     0,     0,     9,     0,     0,
+       0,     0,     0,    19,    94,     0,   221,   221,     0,   301,
+       0,     0,     0,     0,     0,   222,     0,   222,   222,     0,
+       0,   316,     0,     0,     0,     0,   291,     0,   223,   333,
+     223,     0,     0,     0,   334,   335,     0,     0,     0,     0,
+       0,     0,   222,   222,     0,     0,     0,     0,   336,   337,
+     338,   339,   340,   341,   342,   343,   344,   345,   346,     0,
+       0,     0,     0,     0,     0,     0,     0,    19,    94,     0,
+       0,     0,     0,     0,     0,     0,     0,   223,     0,   223,
+     223,   351,   352,   353,   354,   355,   356,   357,   358,   359,
+     360,     0,   362,   363,   364,   365,   366,   367,   368,   369,
+       0,   372,     0,     0,   223,   223,   373,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   374,   375,   376,
+     377,   378,   379,   380,   381,   382,   383,   384,   385,   386,
+     387,   388,   389,   390,   391,   392,   393,   394,   395,   396,
+     397,   398,   399,   401,   266,   267,     0,   269,   270,   271,
+     272,   273,   274,   275,     0,   412,     0,   414,     0,     0,
+     421,     0,     0,     0,     0,     0,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,     0,     0,   266,   267,     0,
+       0,   270,   271,   272,   273,   274,   275,     0,   432,   433,
+     434,   435,   436,   437,   438,   439,   440,   441,   442,     0,
+     444,   277,   156,   279,   280,   281,   282,   283,     0,     0,
+       0,     0,     0,   157,     0,     0,   158,   159,     0,   160,
+     161,   162,   163,   465,   164,   165,   166,   167,   168,   169,
+     170,   171,    60,     0,     0,     0,     9,    64,    65,    66,
+      67,   172,     0,     0,     0,     0,     0,     0,    74,     0,
+       0,     0,   372,     0,    80,    81,    82,    83,    84,    85,
+       0,     0,    60,    55,   322,   174,     9,    64,    65,    66,
+      67,     0,     0,   175,   176,     0,     0,     0,    74,   488,
+     489,   490,   491,   492,    80,    81,    82,    83,    84,    85,
+       0,     0,     0,     0,     0,   174,     0,     0,     0,   496,
+       0,     0,     0,   175,   176,     0,    19,    94,     0,     0,
+       0,     0,     0,     0,     0,   497,    59,     0,     0,   500,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   501,
+       0,     0,   504,     0,   506,   508,    19,    94,     0,     0,
+       0,    60,    61,    62,    63,     9,    64,    65,    66,    67,
+     525,    68,    69,    70,    71,    72,    73,    74,    75,    76,
+      77,    78,    79,    80,    81,    82,    83,    84,    85,    86,
+      87,     0,     0,     0,   400,   250,     0,     0,    89,     0,
+       0,     0,     0,     0,   549,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,    90,    91,     0,    59,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   517,
-       0,     0,     0,     0,   518,     0,     0,     0,     0,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   446,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   447,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,    92,     0,     0,    93,    19,    94,    35,    95,    96,
+      97,    98,    60,    61,    62,    63,     9,    64,    65,    66,
+      67,     0,    68,    69,    70,    71,    72,    73,    74,    75,
+      76,    77,    78,    79,    80,    81,    82,    83,    84,    85,
+      86,    87,   466,     0,     0,    88,     0,     0,   265,    89,
+       0,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,     0,     0,     0,     0,    90,    91,     0,    59,     0,
+       0,     0,     0,     0,   276,   277,   278,   279,   280,   281,
+     282,   283,    92,     0,     0,    93,    19,    94,    35,    95,
+      96,    97,    98,    60,    61,    62,    63,     9,    64,    65,
+      66,    67,     0,    68,    69,    70,    71,    72,    73,    74,
+      75,    76,    77,    78,    79,    80,    81,    82,    83,    84,
+      85,    86,    87,     0,     0,     0,   400,     0,     0,     0,
+      89,     0,    60,     0,     0,     0,     9,    64,    65,    66,
+      67,     0,     0,     0,     0,     0,    90,    91,    74,     0,
+       0,     0,     0,     0,    80,    81,    82,    83,    84,    85,
+       0,   254,     0,    92,   298,   174,    93,    19,    94,    35,
+      95,    96,    97,    98,   157,     0,     0,   158,   159,     0,
+     160,   161,   162,   163,     0,   164,   165,   166,   167,   168,
+     169,   170,   171,    60,     0,     0,     0,     9,    64,    65,
+      66,    67,   172,     0,     0,     0,    19,    94,     0,    74,
+       0,   255,   256,     0,     0,    80,    81,    82,    83,    84,
+      85,     0,     0,     0,    55,     0,   174,   409,     0,     0,
+       0,     0,     0,     0,   175,   176,     0,   157,     0,     0,
+     158,   159,     0,   160,   161,   162,   163,     0,   164,   165,
+     166,   167,   168,   169,   170,   171,    60,     0,     0,     0,
+       9,    64,    65,    66,    67,   172,     0,    19,    94,     0,
+       0,     0,    74,     0,     0,     0,     0,     0,    80,    81,
+      82,    83,    84,    85,     0,     0,     0,    55,     0,   174,
+       0,     0,     0,     0,     0,     0,     0,   175,   176,   157,
+       0,     0,   158,   159,     0,   160,   161,   162,   163,     0,
+     164,   165,   166,   167,   168,   169,   170,   171,    60,     0,
+       0,     0,     9,    64,    65,    66,    67,   172,     0,     0,
+      19,    94,     0,     0,    74,     0,     0,     0,     0,     0,
+      80,    81,    82,    83,    84,    85,     0,     0,    60,    55,
+       0,   174,     9,    64,    65,    66,    67,     0,     0,   175,
+     176,     0,     0,     0,    74,     0,     0,     0,     0,     0,
+      80,    81,    82,    83,    84,    85,     0,     0,     0,     0,
+       0,   174,     0,     0,     0,     0,     0,     0,     0,   370,
+       0,     0,    19,    94,   371,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,    19,    94,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   515,     0,     0,     0,     0,   516,     0,
+       0,     0,     0,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   517,     0,     0,
+       0,     0,   518,     0,     0,     0,     0,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   448,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   449,     0,   274,   275,   276,
-     277,   278,   279,   280,   281,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   450,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   451,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   452,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,     0,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   519,     0,     0,     0,     0,   520,     0,     0,     0,
+       0,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   448,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   449,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   450,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   451,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   453,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   454,     0,   274,   275,   276,
-     277,   278,   279,   280,   281,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   455,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   456,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   457,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,   452,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   453,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   454,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   455,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   456,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   458,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   459,     0,   274,   275,   276,
-     277,   278,   279,   280,   281,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   460,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   462,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   368,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,   457,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   458,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   459,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   460,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   461,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   477,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   479,     0,   274,   275,   276,
-     277,   278,   279,   280,   281,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   483,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   512,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   521,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,   462,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   464,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   370,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   479,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   481,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   522,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   263,     0,     0,   264,   265,   266,   267,   268,   269,
-     270,   271,   272,   273,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   527,     0,   274,   275,   276,
-     277,   278,   279,   280,   281,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,   529,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   263,
-       0,     0,   264,   265,   266,   267,   268,   269,   270,   271,
-     272,   273,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   541,     0,   274,   275,   276,   277,   278,
-     279,   280,   281,   263,     0,     0,   264,   265,   266,   267,
-     268,   269,   270,   271,   272,   273,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,   554,     0,   274,
-     275,   276,   277,   278,   279,   280,   281,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,   485,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   514,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   523,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,   524,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   265,     0,     0,   266,   267,   268,   269,
+     270,   271,   272,   273,   274,   275,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   529,     0,   276,
+     277,   278,   279,   280,   281,   282,   283,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   468,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,   531,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   265,     0,     0,   266,   267,   268,   269,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   543,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,   265,     0,     0,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,     0,   556,
+       0,   276,   277,   278,   279,   280,   281,   282,   283,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   468,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   469,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   470,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   471,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   472,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   473,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   474,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   475,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   493,     0,     0,     0,     0,     0,   265,
+       0,     0,   266,   267,   268,   269,   270,   271,   272,   273,
+     274,   275,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,   276,   277,   278,   279,   280,
+     281,   282,   283,   447,     0,     0,     0,     0,   265,     0,
+       0,   266,   267,   268,   269,   270,   271,   272,   273,   274,
+     275,     0,     0,     0,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,   276,   277,   278,   279,   280,   281,
+     282,   283,   463,     0,     0,     0,     0,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   469,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,     0,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   498,     0,     0,     0,     0,   265,     0,     0,   266,
+     267,   268,   269,   270,   271,   272,   273,   274,   275,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   470,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,     0,   276,   277,   278,   279,   280,   281,   282,   283,
+     467,     0,   265,     0,     0,   266,   267,   268,   269,   270,
+     271,   272,   273,   274,   275,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   276,   277,
+     278,   279,   280,   281,   282,   283,   411,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   471,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
+       0,     0,     0,   276,   277,   278,   279,   280,   281,   282,
+     283,   424,   265,     0,     0,   266,   267,   268,   269,   270,
+     271,   272,   273,   274,   275,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,     0,   276,   277,
+     278,   279,   280,   281,   282,   283,   513,   265,     0,     0,
+     266,   267,   268,   269,   270,   271,   272,   273,   274,   275,
+     265,     0,     0,   266,   267,   268,   269,   270,   271,   272,
+     273,   274,   275,   276,   277,   278,   279,   280,   281,   282,
+     283,     0,     0,     0,     0,     0,   276,   277,   278,   279,
+     280,   281,   282,   283,   266,   267,     0,     0,   270,   271,
+     272,   273,   274,   275,   266,   267,     0,     0,   270,   271,
+     272,   273,   274,   275,     0,     0,     0,   276,   277,   278,
+     279,   280,   281,   282,   283,     0,     0,     0,   277,   278,
+     279,   280,   281,   282,   283,   266,   267,     0,     0,   270,
+     271,   272,   273,   274,   275,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   472,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   473,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   491,     0,     0,     0,     0,     0,   263,     0,     0,
-     264,   265,   266,   267,   268,   269,   270,   271,   272,   273,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,   274,   275,   276,   277,   278,   279,   280,
-     281,   445,     0,     0,     0,     0,   263,     0,     0,   264,
-     265,   266,   267,   268,   269,   270,   271,   272,   273,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,   274,   275,   276,   277,   278,   279,   280,   281,
-     461,     0,     0,     0,     0,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   496,
-       0,     0,     0,     0,   263,     0,     0,   264,   265,   266,
-     267,   268,   269,   270,   271,   272,   273,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-     274,   275,   276,   277,   278,   279,   280,   281,   465,     0,
-     263,     0,     0,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   274,   275,   276,   277,
-     278,   279,   280,   281,   409,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,   274,   275,   276,   277,   278,   279,   280,   281,   422,
-     263,     0,     0,   264,   265,   266,   267,   268,   269,   270,
-     271,   272,   273,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,   274,   275,   276,   277,
-     278,   279,   280,   281,   511,   263,     0,     0,   264,   265,
-     266,   267,   268,   269,   270,   271,   272,   273,   263,     0,
-       0,   264,   265,   266,   267,   268,   269,   270,   271,   272,
-     273,   274,   275,   276,   277,   278,   279,   280,   281,     0,
-       0,     0,     0,     0,   274,   275,   276,   277,   278,   279,
-     280,   281
+       0,   279,   280,   281,   282,   283
   };
 
   const short
   parser::yycheck_[] =
   {
-       0,   304,    45,    23,    32,    53,     6,     7,     8,   304,
-     304,   132,    12,     3,     4,    46,   132,    53,    45,    50,
-      51,    52,   115,   116,   294,    70,    11,    12,    13,    14,
-      15,    31,    17,    18,    19,    70,    36,    37,    38,    71,
-      74,    75,    90,     0,    76,   315,   316,    47,    76,   111,
-      36,    37,    38,    53,    90,   117,    80,    45,    58,   121,
-      45,    41,    71,    53,    71,    45,    71,    76,    58,    76,
-      53,    76,   154,   116,    71,    53,   158,   347,    41,    76,
-      71,    80,    45,    70,   117,    76,    74,    87,    41,   116,
-      90,   514,    45,   516,    74,   518,   217,    77,    71,    71,
-      90,   217,    70,    76,    76,    71,   154,    90,    53,    70,
-     158,    74,    90,    80,    77,    71,    70,    70,   154,    96,
-      76,    74,   158,    72,    77,   173,   174,   115,   116,   177,
-      70,   116,   132,    70,    70,   115,   116,   173,   174,   260,
-      70,   177,   132,   163,   260,    90,    41,   112,   113,   114,
-      45,    70,   115,   116,   154,    71,    53,    70,   158,    70,
-      76,    71,   115,   116,   154,    70,    76,    71,   158,    70,
-     170,   154,    76,   173,   174,   158,   154,   177,    70,    74,
-     158,    70,    77,   173,   174,    70,    70,   177,    70,    53,
-     173,   174,    70,    90,   177,   173,   174,   318,   319,   177,
-      70,    70,   318,   319,    41,    70,   476,   116,    45,   154,
-      78,    53,    74,   158,    74,    74,   298,   217,    74,    74,
-     115,   116,    53,   493,    74,   528,    90,   217,   173,   174,
-      74,    80,   177,   528,   528,    78,    70,    74,    70,    79,
-      77,    70,    70,    70,    80,    84,    85,    80,    90,    70,
-     298,    70,    74,    70,   524,    80,   304,   154,    78,    90,
-     260,   158,   298,   110,   111,   112,   113,   114,   304,   539,
-     260,   110,   111,   112,   113,   114,   173,   174,   115,   116,
-     177,    80,    80,    80,    80,    74,    70,    78,    71,    41,
-     154,    29,    79,    45,   158,   295,   417,   121,   298,    79,
-      70,   417,    96,    70,   304,   305,    70,    70,   298,   173,
-     174,   116,   154,   177,   304,   298,   158,    70,   318,   319,
-     298,   304,    74,   154,    70,    77,   304,   158,   318,   319,
-      80,   173,   174,    70,    53,   177,    75,    80,    80,    75,
-      70,    27,   173,   174,    53,   345,   177,    80,   348,    32,
-      41,    80,    80,   298,    45,    46,    47,    48,    49,   304,
-      80,    76,    80,   115,   116,    70,    57,    80,    71,    71,
-      71,    90,    63,    64,    65,    66,    67,    68,    71,    12,
-      80,    90,    80,    74,    80,    41,    12,    12,   528,    45,
-      47,    82,    83,    90,   163,   477,   177,   479,    -1,    53,
-      -1,   298,    -1,    -1,    -1,    -1,    -1,   304,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   417,    74,    -1,
-      -1,    77,    -1,    -1,   115,   116,    -1,   417,    -1,   477,
-      -1,   479,    -1,    41,   298,   154,    90,    45,    -1,   158,
-     304,   477,    -1,   479,   526,   154,    -1,   529,    -1,   158,
-      -1,    -1,   483,    -1,   173,   174,   298,    -1,   177,   115,
-     116,    -1,   304,    -1,   173,   174,    74,   298,   177,    77,
-      -1,   553,   554,   304,    -1,    -1,    -1,   477,   526,   479,
-     528,   529,   482,    -1,    -1,    -1,    -1,   477,    -1,   479,
-     526,    41,   528,   529,   477,    45,   479,    -1,    53,   477,
-     154,   479,    -1,    -1,   158,   553,   554,   115,   116,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   553,   554,   173,
-     174,    -1,    -1,   177,    74,    -1,   526,    77,   528,   529,
-      -1,    -1,   477,    -1,   479,    90,   526,    -1,   528,   529,
-      -1,    -1,    -1,   526,    -1,   528,   529,    -1,   526,    -1,
-     528,   529,    -1,   553,   554,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   553,   554,   115,   116,    -1,    -1,    -1,
-     553,   554,    -1,    -1,    -1,   553,   554,    -1,    -1,   298,
-     477,   526,   479,   528,   529,   304,    -1,    -1,    -1,   298,
-      -1,    -1,    -1,    -1,    41,   304,    -1,    -1,    45,   154,
-      -1,    -1,    -1,   158,    53,    -1,    41,    -1,   553,   554,
-      45,    -1,    53,   477,    -1,   479,    -1,    -1,   173,   174,
-      -1,    -1,   177,    -1,    -1,    -1,    53,    74,    -1,   526,
-      77,   528,   529,    -1,    -1,   477,    -1,   479,    -1,    74,
-      -1,    90,    77,    -1,   298,    -1,   477,    -1,   479,    90,
-     304,    -1,    -1,    -1,    -1,    -1,   553,   554,    -1,    -1,
-      -1,    -1,   526,    90,   528,   529,    -1,    -1,   115,   116,
+       0,   134,    70,    23,   306,    48,     6,     7,     8,    52,
+      53,    54,    12,     3,     4,   306,   306,    45,     0,    55,
+      45,   296,   111,   134,    32,    41,    55,   113,   117,    45,
+      70,    31,   121,   115,   116,    45,    71,    37,    38,    39,
+     117,    76,   317,   318,    11,    12,    13,    14,    15,    49,
+      17,    18,    19,    80,    70,    55,    92,    80,    74,    70,
+      60,    77,    41,    92,    74,    55,    45,   516,    76,   518,
+      60,   520,    55,    70,   349,    71,    71,    71,    45,    71,
+      76,    76,    76,   156,    76,    71,   219,   160,   116,    89,
+      76,   116,    92,    74,    75,    74,    71,    70,    77,   115,
+     116,    76,    92,   116,    80,   115,   116,    71,   219,    92,
+      71,    55,    76,    71,    71,    76,    71,    71,    76,    76,
+     156,    76,    96,    72,   160,    55,    78,   156,    70,   262,
+      70,   160,    70,    70,   134,    70,   115,   116,    70,   175,
+     176,    70,    70,   179,   134,   165,   175,   176,    92,   116,
+     179,   262,    70,    70,    55,    70,   156,    37,    38,    39,
+     160,    70,    92,    70,    55,    70,   156,   112,   113,   114,
+     160,    70,   172,   156,    70,   175,   176,   160,    41,   179,
+      70,    70,    45,    70,    78,   175,   176,   320,   321,   179,
+     116,    92,   175,   176,    80,    74,   179,    74,    74,    74,
+      74,    92,    74,   478,   110,   111,   112,   113,   114,   320,
+     321,    74,   156,    74,    77,    70,   160,    55,    70,   219,
+     495,    70,    70,    70,    55,    79,   156,   300,   530,   219,
+     160,   175,   176,    70,    80,   179,    80,    70,    74,   530,
+     530,    80,    70,    78,    70,   175,   176,    74,    80,   179,
+      80,   526,   115,   116,    92,   156,    80,    80,    55,   160,
+      78,    92,   262,    71,   300,   156,   541,    29,   121,   160,
+     306,   300,   262,    79,   175,   176,    79,   306,   179,    96,
+      70,    70,    70,    70,   175,   176,   419,   116,   179,    70,
+      70,    70,    75,    70,    80,    92,    80,   297,    80,    41,
+     300,    75,    27,    45,    80,    32,   306,   307,   419,    80,
+     300,    80,    55,    80,    80,    70,   306,   300,   156,    80,
+     320,   321,   160,   306,    76,   156,    71,    71,    12,   160,
+     320,   321,    74,    71,    71,    77,    41,   175,   176,    80,
+      45,   179,    12,    12,   175,   176,    55,   347,   179,    92,
+     350,    41,    80,    41,    80,    45,   300,    45,   179,   156,
+      41,   530,   306,   160,    45,   165,    49,    -1,    92,    74,
+     300,    -1,    77,   115,   116,    -1,   306,    -1,   175,   176,
+      -1,    -1,   179,    92,    74,    -1,    74,    77,    -1,    77,
+      -1,    -1,    -1,    74,    -1,    -1,    77,    -1,    -1,   300,
+      -1,    -1,    -1,    -1,    -1,   306,   479,    -1,   481,   300,
+     115,   116,    55,   156,    -1,   306,    -1,   160,    -1,   419,
+      -1,    -1,    -1,    -1,    -1,   115,   116,   115,   116,   419,
+      -1,    -1,   175,   176,   115,   116,   179,    -1,    -1,    -1,
+      41,    -1,   485,   479,    45,   481,    -1,   156,    -1,    92,
+     479,   160,   481,    -1,    -1,   528,    -1,    -1,   531,    -1,
+      -1,    -1,   300,    -1,    -1,    -1,   175,   176,   306,   300,
+     179,    -1,    -1,    74,    -1,   306,    77,    -1,    -1,   479,
+      -1,   481,   555,   556,   484,    -1,    -1,    -1,    -1,   479,
+      -1,   481,   528,    -1,   530,   531,   479,    -1,   481,   528,
+      -1,   530,   531,   300,    -1,    -1,    -1,    -1,    -1,   306,
+      -1,    -1,    -1,   156,   115,   116,    -1,   160,    -1,   555,
+     556,    -1,    -1,    -1,    -1,    -1,   555,   556,   528,    -1,
+     530,   531,   175,   176,    -1,   479,   179,   481,   528,    -1,
+     530,   531,    -1,    -1,    -1,   528,    55,   530,   531,   479,
+      -1,   481,    -1,    -1,    -1,   555,   556,   300,    -1,    -1,
+      41,    -1,    -1,   306,    45,   555,   556,    -1,    -1,    -1,
+      -1,    41,   555,   556,    -1,    45,    -1,    -1,   479,    -1,
+     481,    -1,    55,    92,   528,    -1,   530,   531,   479,    -1,
+     481,   300,    -1,    74,    84,    85,    77,   306,   528,    -1,
+     530,   531,    -1,    -1,    74,    -1,    -1,    77,    -1,    -1,
+      -1,   555,   556,    -1,    -1,    -1,    -1,    -1,    -1,    92,
+     110,   111,   112,   113,   114,   555,   556,   528,    -1,   530,
+     531,    -1,    -1,    -1,   115,   116,    -1,   528,    -1,   530,
+     531,   479,    -1,   481,    55,   115,   116,   156,   479,    -1,
+     481,   160,    -1,    -1,   555,   556,    -1,   300,    -1,    -1,
+      -1,    -1,    -1,   306,   555,   556,   175,   176,    -1,    -1,
+     179,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    92,   479,   156,   481,    -1,    -1,   160,    -1,    -1,
+     528,    -1,   530,   531,    -1,    -1,    -1,   528,    -1,   530,
+     531,    -1,   175,   176,    -1,    -1,   179,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   555,   556,    41,
+      -1,    -1,    -1,    45,   555,   556,    -1,    -1,    -1,    -1,
+      -1,   528,    -1,   530,   531,    -1,   479,    -1,   481,    -1,
+      -1,    -1,    -1,    -1,    -1,   156,    -1,    -1,    -1,   160,
+      -1,    -1,    74,    -1,    -1,    77,    -1,    -1,   555,   556,
+      82,    83,    -1,    -1,   175,   176,    -1,    -1,   179,    -1,
+     479,    -1,   481,    -1,    96,    97,    98,    99,   100,   101,
+     102,   103,   104,   105,   106,   528,    -1,   530,   531,    -1,
+      -1,   300,    -1,   115,   116,    -1,    -1,   306,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     115,   116,    -1,    -1,   526,    -1,   528,   529,    -1,   553,
-     554,    -1,    -1,    -1,    -1,   526,    -1,   528,   529,    -1,
-      -1,    -1,    -1,    -1,    -1,   154,    -1,    -1,    -1,   158,
-      -1,   553,   554,   154,    -1,    -1,    -1,   158,    -1,    -1,
-      -1,    -1,   553,   554,   173,   174,    -1,   154,   177,    -1,
-      -1,   158,   173,   174,    -1,    -1,   177,    -1,    -1,    -1,
-      -1,    -1,    -1,   298,    -1,    -1,   173,   174,    -1,   304,
-     177,    -1,    -1,    -1,    -1,    -1,    -1,    41,   477,    -1,
-     479,    45,    46,    47,    48,    49,    -1,    -1,   477,    -1,
-     479,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    63,
-      64,    65,    66,    67,    68,    -1,    70,    -1,    -1,    -1,
-      74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,   526,    -1,   528,
-     529,    -1,    -1,    -1,    -1,    -1,    -1,   526,    -1,   528,
-     529,    -1,    -1,   477,    -1,   479,    -1,    -1,    -1,    -1,
-      -1,   115,   116,    -1,   553,   554,   120,   121,    -1,    -1,
-      -1,    -1,    -1,    -1,   553,   554,    -1,    -1,    -1,   298,
-      -1,    -1,    -1,    -1,    -1,   304,    -1,   298,    -1,    -1,
-      41,    -1,    -1,   304,    45,    46,    47,    48,    49,    -1,
-      -1,   298,   526,    -1,   528,   529,    57,   304,    -1,    -1,
-      -1,    -1,    63,    64,    65,    66,    67,    68,    -1,    -1,
-      -1,    11,    -1,    74,    -1,    -1,    -1,    -1,    -1,   553,
-     554,    -1,    22,    -1,    -1,    25,    26,    -1,    28,    29,
-      30,    31,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,   477,    -1,   479,    45,    46,    47,    48,    49,
-      50,    -1,    -1,    -1,   115,   116,    -1,    57,    -1,    -1,
-      -1,    -1,    -1,    63,    64,    65,    66,    67,    68,    48,
-      -1,    41,    72,    73,    74,    45,    -1,    -1,    -1,    -1,
-      -1,    -1,    82,    83,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   526,    -1,   528,   529,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    74,    -1,    85,    77,    -1,    88,
-      89,    -1,    82,    83,    -1,   115,   116,    -1,   553,   554,
-      -1,    -1,    -1,    -1,    -1,    -1,    96,    97,    98,    99,
-     100,   101,   102,   103,   104,   105,   106,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   115,   116,    -1,   477,    -1,
-     479,    -1,    -1,    84,    85,    -1,   477,    -1,   479,    90,
-      91,    92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     477,    -1,   479,    -1,    -1,    -1,   155,    -1,    -1,   110,
-     111,   112,   113,   114,    -1,    -1,    84,    85,   167,    87,
-      88,    89,    90,    91,    92,    93,    -1,   526,    -1,   528,
-     529,    -1,    -1,    -1,    -1,   526,    -1,   528,   529,   107,
-     108,   109,   110,   111,   112,   113,   114,    -1,    -1,   526,
-      -1,   528,   529,    -1,   553,   554,    -1,    -1,    -1,    -1,
-      -1,    -1,   553,   554,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   553,   554,   227,   228,
-     229,   230,   231,   232,   233,   234,   235,   236,    -1,   238,
-     239,   240,   241,   242,   243,   244,   245,    -1,   247,    -1,
-      -1,    -1,    -1,   252,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,   263,   264,   265,   266,   267,   268,
-     269,   270,   271,   272,   273,   274,   275,   276,   277,   278,
-     279,   280,   281,   282,   283,   284,   285,   286,   287,   288,
-     289,    84,    85,    -1,    -1,    88,    89,    90,    91,    92,
-      93,    -1,   301,    -1,   303,    -1,    -1,   306,    -1,    -1,
-      -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,   112,
-     113,   114,    -1,    -1,    84,    85,    -1,    -1,    88,    89,
-      90,    91,    92,    93,    -1,   334,   335,   336,   337,   338,
-     339,   340,   341,   342,   343,   344,    -1,   346,   108,    11,
-     110,   111,   112,   113,   114,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   555,   556,    -1,    -1,    -1,    -1,    -1,   528,
+      -1,   530,   531,    -1,    -1,    -1,    -1,   300,    16,    -1,
+      -1,    -1,    -1,   306,    -1,    -1,   479,    -1,   481,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,   555,   556,    -1,    -1,
+      -1,    -1,    -1,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    -1,    51,    52,    53,    54,    55,    56,    57,
+      58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    -1,    -1,   528,    74,   530,   531,   300,
+      78,    -1,    80,    -1,    -1,   306,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    94,    95,    84,    85,
+      -1,    -1,   555,   556,    90,    91,    92,    93,    -1,    -1,
+      -1,    -1,    -1,   111,    -1,    -1,   114,   115,   116,   117,
+     118,   119,   120,   121,   110,   111,   112,   113,   114,    11,
+      -1,    -1,    50,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       22,    -1,    -1,    25,    26,    -1,    28,    29,    30,    31,
-     369,    33,    34,    35,    36,    37,    38,    39,    40,    41,
-      -1,    -1,    -1,    45,    46,    47,    48,    49,    50,    -1,
-      -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,    -1,   398,
+      -1,    33,    34,    35,    36,    37,    38,    39,    40,    41,
+     479,    -1,   481,    45,    46,    47,    48,    49,    50,    87,
+      -1,    -1,    90,    91,    -1,    57,    -1,    -1,    -1,    -1,
       -1,    63,    64,    65,    66,    67,    68,    -1,    -1,    -1,
-      72,    73,    74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      82,    83,    -1,    -1,    -1,    -1,   425,   426,   427,   428,
-     429,    84,    85,    -1,    -1,    88,    89,    90,    91,    92,
-      93,    -1,    -1,    84,    85,    -1,   445,    88,    89,    90,
-      91,    92,    93,   115,   116,   108,   109,   110,   111,   112,
-     113,   114,   461,    16,    -1,    -1,   465,    -1,    -1,   110,
-     111,   112,   113,   114,    -1,    -1,   475,    -1,    -1,   478,
-      -1,   480,   481,    -1,    -1,    -1,    -1,    -1,    41,    42,
-      43,    44,    45,    46,    47,    48,    49,   496,    51,    52,
-      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
-      63,    64,    65,    66,    67,    68,    69,    70,    -1,    -1,
-      -1,    74,    -1,    -1,    -1,    78,    -1,    80,    -1,    -1,
-      -1,   530,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    94,    95,    -1,    16,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   111,    -1,
-      -1,   114,   115,   116,   117,   118,   119,   120,   121,    41,
-      42,    43,    44,    45,    46,    47,    48,    49,    -1,    51,
-      52,    53,    54,    55,    56,    57,    58,    59,    60,    61,
-      62,    63,    64,    65,    66,    67,    68,    69,    70,    75,
-      -1,    -1,    74,    75,    -1,    81,    78,    -1,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      -1,    -1,    94,    95,    -1,    16,    -1,    -1,    -1,    -1,
-      -1,   107,   108,   109,   110,   111,   112,   113,   114,   111,
-      -1,    -1,   114,   115,   116,   117,   118,   119,   120,   121,
-      41,    42,    43,    44,    45,    46,    47,    48,    49,    -1,
-      51,    52,    53,    54,    55,    56,    57,    58,    59,    60,
-      61,    62,    63,    64,    65,    66,    67,    68,    69,    70,
-      75,    -1,    -1,    74,    -1,    -1,    81,    78,    -1,    84,
-      85,    86,    87,    88,    89,    90,    91,    92,    93,    -1,
-      -1,    -1,    -1,    94,    95,    -1,    16,    -1,    -1,    -1,
-      -1,    -1,   107,   108,   109,   110,   111,   112,   113,   114,
-     111,    -1,    -1,   114,   115,   116,   117,   118,   119,   120,
-     121,    41,    42,    43,    44,    45,    46,    47,    48,    49,
-      -1,    51,    52,    53,    54,    55,    56,    57,    58,    59,
+      72,    73,    74,    -1,    -1,    -1,   479,    -1,   481,    -1,
+      82,    83,    20,    21,    -1,    23,    24,    -1,    -1,   528,
+      -1,   530,   531,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    41,    -1,    -1,    -1,    45,    -1,    -1,
+      -1,    -1,    -1,   115,   116,    -1,   555,   556,    -1,   157,
+      -1,    -1,    -1,    -1,    -1,   528,    -1,   530,   531,    -1,
+      -1,   169,    -1,    -1,    -1,    -1,    74,    -1,   479,    77,
+     481,    -1,    -1,    -1,    82,    83,    -1,    -1,    -1,    -1,
+      -1,    -1,   555,   556,    -1,    -1,    -1,    -1,    96,    97,
+      98,    99,   100,   101,   102,   103,   104,   105,   106,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   115,   116,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   528,    -1,   530,
+     531,   229,   230,   231,   232,   233,   234,   235,   236,   237,
+     238,    -1,   240,   241,   242,   243,   244,   245,   246,   247,
+      -1,   249,    -1,    -1,   555,   556,   254,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,   265,   266,   267,
+     268,   269,   270,   271,   272,   273,   274,   275,   276,   277,
+     278,   279,   280,   281,   282,   283,   284,   285,   286,   287,
+     288,   289,   290,   291,    84,    85,    -1,    87,    88,    89,
+      90,    91,    92,    93,    -1,   303,    -1,   305,    -1,    -1,
+     308,    -1,    -1,    -1,    -1,    -1,    -1,   107,   108,   109,
+     110,   111,   112,   113,   114,    -1,    -1,    84,    85,    -1,
+      -1,    88,    89,    90,    91,    92,    93,    -1,   336,   337,
+     338,   339,   340,   341,   342,   343,   344,   345,   346,    -1,
+     348,   108,    11,   110,   111,   112,   113,   114,    -1,    -1,
+      -1,    -1,    -1,    22,    -1,    -1,    25,    26,    -1,    28,
+      29,    30,    31,   371,    33,    34,    35,    36,    37,    38,
+      39,    40,    41,    -1,    -1,    -1,    45,    46,    47,    48,
+      49,    50,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,
+      -1,    -1,   400,    -1,    63,    64,    65,    66,    67,    68,
+      -1,    -1,    41,    72,    73,    74,    45,    46,    47,    48,
+      49,    -1,    -1,    82,    83,    -1,    -1,    -1,    57,   427,
+     428,   429,   430,   431,    63,    64,    65,    66,    67,    68,
+      -1,    -1,    -1,    -1,    -1,    74,    -1,    -1,    -1,   447,
+      -1,    -1,    -1,    82,    83,    -1,   115,   116,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   463,    16,    -1,    -1,   467,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   477,
+      -1,    -1,   480,    -1,   482,   483,   115,   116,    -1,    -1,
+      -1,    41,    42,    43,    44,    45,    46,    47,    48,    49,
+     498,    51,    52,    53,    54,    55,    56,    57,    58,    59,
       60,    61,    62,    63,    64,    65,    66,    67,    68,    69,
-      70,    75,    -1,    -1,    74,    -1,    -1,    81,    78,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    94,    95,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,   111,    12,    -1,   114,   115,   116,   117,   118,   119,
-     120,   121,    22,    -1,    -1,    25,    26,    -1,    28,    29,
-      30,    31,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    -1,    -1,    -1,    45,    46,    47,    48,    49,
-      50,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
-      -1,    -1,    -1,    63,    64,    65,    66,    67,    68,    -1,
-      -1,    -1,    72,    -1,    74,    12,    -1,    -1,    -1,    -1,
-      -1,    -1,    82,    83,    -1,    22,    -1,    -1,    25,    26,
-      -1,    28,    29,    30,    31,    -1,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    -1,    -1,    -1,    45,    46,
-      47,    48,    49,    50,    -1,   115,   116,    -1,    20,    21,
-      57,    23,    24,    -1,    -1,    -1,    63,    64,    65,    66,
-      67,    68,    -1,    -1,    -1,    72,    -1,    74,    -1,    41,
-      -1,    -1,    -1,    45,    -1,    82,    83,    71,    -1,    -1,
+      70,    -1,    -1,    -1,    74,    75,    -1,    -1,    78,    -1,
+      -1,    -1,    -1,    -1,   532,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    94,    95,    -1,    16,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,   111,    -1,    -1,   114,   115,   116,   117,   118,   119,
+     120,   121,    41,    42,    43,    44,    45,    46,    47,    48,
+      49,    -1,    51,    52,    53,    54,    55,    56,    57,    58,
+      59,    60,    61,    62,    63,    64,    65,    66,    67,    68,
+      69,    70,    75,    -1,    -1,    74,    -1,    -1,    81,    78,
+      -1,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+      93,    -1,    -1,    -1,    -1,    94,    95,    -1,    16,    -1,
+      -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,   112,
+     113,   114,   111,    -1,    -1,   114,   115,   116,   117,   118,
+     119,   120,   121,    41,    42,    43,    44,    45,    46,    47,
+      48,    49,    -1,    51,    52,    53,    54,    55,    56,    57,
+      58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
+      68,    69,    70,    -1,    -1,    -1,    74,    -1,    -1,    -1,
+      78,    -1,    41,    -1,    -1,    -1,    45,    46,    47,    48,
+      49,    -1,    -1,    -1,    -1,    -1,    94,    95,    57,    -1,
+      -1,    -1,    -1,    -1,    63,    64,    65,    66,    67,    68,
+      -1,    70,    -1,   111,    12,    74,   114,   115,   116,   117,
+     118,   119,   120,   121,    22,    -1,    -1,    25,    26,    -1,
+      28,    29,    30,    31,    -1,    33,    34,    35,    36,    37,
+      38,    39,    40,    41,    -1,    -1,    -1,    45,    46,    47,
+      48,    49,    50,    -1,    -1,    -1,   115,   116,    -1,    57,
+      -1,   120,   121,    -1,    -1,    63,    64,    65,    66,    67,
+      68,    -1,    -1,    -1,    72,    -1,    74,    12,    -1,    -1,
+      -1,    -1,    -1,    -1,    82,    83,    -1,    22,    -1,    -1,
+      25,    26,    -1,    28,    29,    30,    31,    -1,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    -1,    -1,    -1,
+      45,    46,    47,    48,    49,    50,    -1,   115,   116,    -1,
+      -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,    63,    64,
+      65,    66,    67,    68,    -1,    -1,    -1,    72,    -1,    74,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    82,    83,    22,
+      -1,    -1,    25,    26,    -1,    28,    29,    30,    31,    -1,
+      33,    34,    35,    36,    37,    38,    39,    40,    41,    -1,
+      -1,    -1,    45,    46,    47,    48,    49,    50,    -1,    -1,
+     115,   116,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,
+      63,    64,    65,    66,    67,    68,    -1,    -1,    41,    72,
+      -1,    74,    45,    46,    47,    48,    49,    -1,    -1,    82,
+      83,    -1,    -1,    -1,    57,    -1,    -1,    -1,    -1,    -1,
+      63,    64,    65,    66,    67,    68,    -1,    -1,    -1,    -1,
+      -1,    74,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,
+      -1,    -1,   115,   116,    76,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,   115,   116,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    71,    -1,    -1,    -1,    -1,    76,    -1,
+      -1,    -1,    -1,    81,    -1,    -1,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,
+     108,   109,   110,   111,   112,   113,   114,    71,    -1,    -1,
       -1,    -1,    76,    -1,    -1,    -1,    -1,    81,    -1,    -1,
       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    74,    -1,    -1,    77,    -1,    -1,   115,   116,
-      82,    83,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    -1,    -1,    -1,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    22,   115,   116,    25,    26,    -1,    28,    29,
-      30,    31,    -1,    33,    34,    35,    36,    37,    38,    39,
-      40,    41,    -1,    -1,    -1,    45,    46,    47,    48,    49,
-      50,    -1,    -1,    -1,    -1,    -1,    -1,    57,    -1,    -1,
-      -1,    -1,    -1,    63,    64,    65,    66,    67,    68,    -1,
-      -1,    -1,    72,    -1,    74,    -1,    -1,    -1,    -1,    -1,
-      -1,    71,    82,    83,    -1,    -1,    76,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
+     114,    71,    -1,    -1,    -1,    -1,    76,    -1,    -1,    -1,
       -1,    81,    -1,    -1,    84,    85,    86,    87,    88,    89,
       90,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,   115,   116,   107,   108,   109,
-     110,   111,   112,   113,   114,    71,    -1,    -1,    -1,    -1,
-      76,    -1,    -1,    -1,    -1,    81,    -1,    -1,    84,    85,
+      -1,    -1,    -1,    -1,    -1,    71,    -1,   107,   108,   109,
+     110,   111,   112,   113,   114,    81,    -1,    -1,    84,    85,
       86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   107,   108,   109,   110,   111,   112,   113,   114,    71,
-      -1,    -1,    -1,    -1,    76,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,
+      -1,   107,   108,   109,   110,   111,   112,   113,   114,    81,
       -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
       92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    71,    -1,   107,   108,   109,   110,   111,
@@ -5233,39 +5245,48 @@ namespace xsk { namespace arc { namespace t6 {
       -1,   107,   108,   109,   110,   111,   112,   113,   114,    81,
       -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
       92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    71,    -1,   107,   108,   109,   110,   111,
-     112,   113,   114,    81,    -1,    -1,    84,    85,    86,    87,
-      88,    89,    90,    91,    92,    93,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    71,    -1,   107,
-     108,   109,   110,   111,   112,   113,   114,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
-      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
-     114,    75,    -1,    -1,    -1,    -1,    -1,    81,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    75,    -1,    -1,    -1,    -1,    -1,    81,
+      -1,    -1,    84,    85,    86,    87,    88,    89,    90,    91,
+      92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,
+     112,   113,   114,    76,    -1,    -1,    -1,    -1,    81,    -1,
+      -1,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+      93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,   112,
+     113,   114,    76,    -1,    -1,    -1,    -1,    81,    -1,    -1,
       84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
@@ -5273,30 +5294,29 @@ namespace xsk { namespace arc { namespace t6 {
       85,    86,    87,    88,    89,    90,    91,    92,    93,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,   107,   108,   109,   110,   111,   112,   113,   114,
-      76,    -1,    -1,    -1,    -1,    81,    -1,    -1,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
+      79,    -1,    81,    -1,    -1,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,   108,
+     109,   110,   111,   112,   113,   114,    80,    81,    -1,    -1,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   107,   108,   109,   110,   111,   112,   113,   114,    76,
-      -1,    -1,    -1,    -1,    81,    -1,    -1,    84,    85,    86,
-      87,    88,    89,    90,    91,    92,    93,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-     107,   108,   109,   110,   111,   112,   113,   114,    79,    -1,
+      -1,    -1,    -1,   107,   108,   109,   110,   111,   112,   113,
+     114,    80,    81,    -1,    -1,    84,    85,    86,    87,    88,
+      89,    90,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,   107,   108,
+     109,   110,   111,   112,   113,   114,    80,    81,    -1,    -1,
+      84,    85,    86,    87,    88,    89,    90,    91,    92,    93,
       81,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,
-     111,   112,   113,   114,    80,    81,    -1,    -1,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    -1,    -1,
+      91,    92,    93,   107,   108,   109,   110,   111,   112,   113,
+     114,    -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,
+     111,   112,   113,   114,    84,    85,    -1,    -1,    88,    89,
+      90,    91,    92,    93,    84,    85,    -1,    -1,    88,    89,
+      90,    91,    92,    93,    -1,    -1,    -1,   107,   108,   109,
+     110,   111,   112,   113,   114,    -1,    -1,    -1,   108,   109,
+     110,   111,   112,   113,   114,    84,    85,    -1,    -1,    88,
+      89,    90,    91,    92,    93,    -1,    -1,    -1,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,   107,   108,   109,   110,   111,   112,   113,   114,    80,
-      81,    -1,    -1,    84,    85,    86,    87,    88,    89,    90,
-      91,    92,    93,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,   107,   108,   109,   110,
-     111,   112,   113,   114,    80,    81,    -1,    -1,    84,    85,
-      86,    87,    88,    89,    90,    91,    92,    93,    81,    -1,
-      -1,    84,    85,    86,    87,    88,    89,    90,    91,    92,
-      93,   107,   108,   109,   110,   111,   112,   113,   114,    -1,
-      -1,    -1,    -1,    -1,   107,   108,   109,   110,   111,   112,
-     113,   114
+      -1,   110,   111,   112,   113,   114
   };
 
   const unsigned char
@@ -5305,60 +5325,60 @@ namespace xsk { namespace arc { namespace t6 {
        0,    11,    12,    13,    14,    15,    17,    18,    19,    45,
      116,   132,   133,   134,   135,   136,   137,   138,   222,   115,
      116,   223,   223,    70,   222,   222,   222,     0,   134,   135,
-     136,    70,    80,    80,   117,   225,    70,    70,    70,   184,
-     185,   222,    71,   184,   184,   184,    71,    76,    96,    80,
-      71,    71,    71,    72,   144,   185,   222,    16,    41,    42,
-      43,    44,    46,    47,    48,    49,    51,    52,    53,    54,
-      55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
-      65,    66,    67,    68,    69,    70,    74,    78,    94,    95,
-     111,   114,   116,   118,   119,   120,   121,   169,   174,   175,
-     176,   177,   178,   179,   180,   181,   182,   183,   188,   189,
-     190,   191,   192,   193,   194,   195,   196,   197,   198,   199,
-     200,   201,   202,   203,   204,   205,   206,   207,   208,   209,
-     210,   211,   212,   213,   214,   215,   216,   217,   218,   219,
-     220,   222,   223,   224,   225,   226,   227,   228,   229,   230,
-     231,   144,   144,   144,    11,    22,    25,    26,    28,    29,
-      30,    31,    33,    34,    35,    36,    37,    38,    39,    40,
-      50,    73,    74,    82,    83,   139,   140,   142,   143,   144,
-     146,   147,   148,   149,   150,   151,   152,   153,   154,   155,
-     156,   157,   158,   159,   160,   161,   162,   163,   164,   165,
-     166,   167,   168,   171,   172,   173,   180,   181,   194,   200,
-     201,   202,   203,   204,   205,   208,   209,   212,   215,   216,
-     217,   218,   222,   223,    74,   222,   223,    70,    70,    70,
+     136,    70,   113,    80,    80,   117,   225,    70,    70,    70,
+     184,   185,   222,   116,    71,   184,   184,   184,    71,    76,
+      96,    80,    71,    71,    71,    72,   144,   185,   222,    16,
+      41,    42,    43,    44,    46,    47,    48,    49,    51,    52,
+      53,    54,    55,    56,    57,    58,    59,    60,    61,    62,
+      63,    64,    65,    66,    67,    68,    69,    70,    74,    78,
+      94,    95,   111,   114,   116,   118,   119,   120,   121,   169,
+     174,   175,   176,   177,   178,   179,   180,   181,   182,   183,
+     188,   189,   190,   191,   192,   193,   194,   195,   196,   197,
+     198,   199,   200,   201,   202,   203,   204,   205,   206,   207,
+     208,   209,   210,   211,   212,   213,   214,   215,   216,   217,
+     218,   219,   220,   222,   223,   224,   225,   226,   227,   228,
+     229,   230,   231,   144,   144,   144,    11,    22,    25,    26,
+      28,    29,    30,    31,    33,    34,    35,    36,    37,    38,
+      39,    40,    50,    73,    74,    82,    83,   139,   140,   142,
+     143,   144,   146,   147,   148,   149,   150,   151,   152,   153,
+     154,   155,   156,   157,   158,   159,   160,   161,   162,   163,
+     164,   165,   166,   167,   168,   171,   172,   173,   180,   181,
+     194,   200,   201,   202,   203,   204,   205,   208,   209,   212,
+     215,   216,   217,   218,   222,   223,    74,   222,   223,    70,
       70,    70,    70,    70,    70,    70,    70,    70,    70,    70,
-      70,    70,    70,    70,    70,    70,   169,    74,    75,   222,
-     169,   169,    70,   120,   121,   180,   181,   208,   209,   211,
-     212,   222,   116,    81,    84,    85,    86,    87,    88,    89,
-      90,    91,    92,    93,   107,   108,   109,   110,   111,   112,
-     113,   114,    74,    74,    74,    74,    74,    74,    74,    74,
-      77,   182,   183,   222,    70,    78,    12,   139,   141,   169,
-      80,    70,   139,    70,    70,    70,    70,   111,   225,   229,
-      79,    80,    80,    80,   169,    70,    70,   222,   212,   212,
-      73,   140,    80,    80,    80,    80,    80,    20,    21,    23,
-      24,    77,    82,    83,    96,    97,    98,    99,   100,   101,
-     102,   103,   104,   105,   106,    78,    74,    70,    78,   169,
-     169,   169,   169,   169,   169,   169,   169,   169,   169,    71,
-     169,   169,   169,   169,   169,   169,   169,   169,    71,    76,
+      70,    70,    70,    70,    70,    70,    70,    70,   169,    74,
+      75,   222,   169,   169,    70,   120,   121,   180,   181,   208,
+     209,   211,   212,   222,   116,    81,    84,    85,    86,    87,
+      88,    89,    90,    91,    92,    93,   107,   108,   109,   110,
+     111,   112,   113,   114,    74,    74,    74,    74,    74,    74,
+      74,    74,    77,   182,   183,   222,    70,    78,    12,   139,
+     141,   169,    80,    70,   139,    70,    70,    70,    70,   111,
+     225,   229,    79,    80,    80,    80,   169,    70,    70,   222,
+     212,   212,    73,   140,    80,    80,    80,    80,    80,    20,
+      21,    23,    24,    77,    82,    83,    96,    97,    98,    99,
+     100,   101,   102,   103,   104,   105,   106,    78,    74,    70,
+      78,   169,   169,   169,   169,   169,   169,   169,   169,   169,
+     169,    71,   169,   169,   169,   169,   169,   169,   169,   169,
+      71,    76,   169,   169,   169,   169,   169,   169,   169,   169,
      169,   169,   169,   169,   169,   169,   169,   169,   169,   169,
      169,   169,   169,   169,   169,   169,   169,   169,   169,   169,
-     169,   169,   169,   169,   169,   169,   169,   169,    74,   169,
-      45,   116,   221,   169,   186,   187,   222,    12,   139,    80,
-     169,    29,   169,   145,   171,   172,   173,   212,   222,   169,
-      79,    79,    80,   186,   186,    96,    70,    70,    70,    70,
-     169,   169,   169,   169,   169,   169,   169,   169,   169,   169,
-     169,   222,   169,   186,   222,    76,    71,    71,    71,    71,
+      74,   169,    45,   116,   221,   169,   186,   187,   222,    12,
+     139,    80,   169,    29,   169,   145,   171,   172,   173,   212,
+     222,   169,    79,    79,    80,   186,   186,    96,    70,    70,
+      70,    70,   169,   169,   169,   169,   169,   169,   169,   169,
+     169,   169,   169,   222,   169,   186,   222,    76,    71,    71,
       71,    71,    71,    71,    71,    71,    71,    71,    71,    71,
-      71,    76,    71,   169,    75,    79,    75,    75,    75,    75,
-      75,    75,    75,    75,    71,    76,    70,    71,    70,    71,
-      80,    32,    76,    71,    71,    71,   169,   169,   169,   169,
-     169,    75,    71,    70,   169,   169,    76,    75,   169,   169,
-     186,   139,   169,   139,   169,   170,   169,   222,   144,    80,
-      80,    80,    71,    71,    76,    71,    76,    71,    76,    75,
-     186,    71,    71,   169,    70,    71,    27,    71,    80,    71,
-      32,    80,    80,   186,   187,    80,   187,    80,   187,    70,
-      71,    71,   186,   139,    80,   145,   139,   169,    71,    71,
-      71,   186,    71,    71,    71,    80,    80,    80,    71,   139,
-     139
+      71,    71,    71,    76,    71,   169,    75,    79,    75,    75,
+      75,    75,    75,    75,    75,    75,    71,    76,    70,    71,
+      70,    71,    80,    32,    76,    71,    71,    71,   169,   169,
+     169,   169,   169,    75,    71,    70,   169,   169,    76,    75,
+     169,   169,   186,   139,   169,   139,   169,   170,   169,   222,
+     144,    80,    80,    80,    71,    71,    76,    71,    76,    71,
+      76,    75,   186,    71,    71,   169,    70,    71,    27,    71,
+      80,    71,    32,    80,    80,   186,   187,    80,   187,    80,
+     187,    70,    71,    71,   186,   139,    80,   145,   139,   169,
+      71,    71,    71,   186,    71,    71,    71,    80,    80,    80,
+      71,   139,   139
   };
 
   const unsigned char
@@ -5389,8 +5409,8 @@ namespace xsk { namespace arc { namespace t6 {
      206,   207,   207,   208,   208,   208,   208,   208,   208,   208,
      208,   209,   210,   211,   212,   212,   212,   212,   212,   212,
      212,   212,   212,   213,   214,   215,   216,   217,   218,   219,
-     220,   221,   222,   222,   223,   223,   224,   225,   226,   227,
-     228,   228,   229,   229,   230,   231
+     220,   221,   222,   222,   223,   223,   223,   224,   225,   226,
+     227,   228,   228,   229,   229,   230,   231
   };
 
   const signed char
@@ -5421,8 +5441,8 @@ namespace xsk { namespace arc { namespace t6 {
        4,     2,     3,     4,     4,     4,     4,     4,     4,     4,
        4,     3,     3,     3,     1,     1,     1,     1,     1,     1,
        1,     1,     1,     2,     1,     1,     1,     1,     1,     2,
-       1,     1,     1,     1,     1,     1,     1,     1,     7,     1,
-       2,     1,     2,     1,     1,     1
+       1,     1,     1,     1,     3,     1,     1,     1,     1,     7,
+       1,     2,     1,     2,     1,     1,     1
   };
 
 
@@ -5457,8 +5477,8 @@ namespace xsk { namespace arc { namespace t6 {
      860,   865,   867,   872,   874,   876,   878,   880,   882,   884,
      886,   891,   896,   901,   906,   907,   908,   909,   910,   911,
      912,   913,   914,   918,   923,   928,   933,   938,   943,   948,
-     953,   958,   963,   965,   970,   972,   977,   982,   987,   992,
-     997,   999,  1004,  1006,  1011,  1016
+     953,   958,   963,   965,   970,   972,   974,   979,   984,   989,
+     994,   999,  1001,  1006,  1008,  1013,  1018
   };
 
   void
@@ -5491,12 +5511,12 @@ namespace xsk { namespace arc { namespace t6 {
 
 #line 13 "parser.ypp"
 } } } // xsk::arc::t6
-#line 5495 "parser.cpp"
+#line 5515 "parser.cpp"
 
-#line 1020 "parser.ypp"
-
-
-void xsk::arc::t6::parser::error(const xsk::arc::location& loc, const std::string& msg)
-{
-    throw xsk::arc::comp_error(loc, msg);
-}
+#line 1022 "parser.ypp"
+
+
+void xsk::arc::t6::parser::error(const xsk::arc::location& loc, const std::string& msg)
+{
+    throw xsk::arc::comp_error(loc, msg);
+}
diff --git a/src/t6/parser.hpp b/src/t6/parser.hpp
index 5946a423..ef2bb21f 100644
--- a/src/t6/parser.hpp
+++ b/src/t6/parser.hpp
@@ -5568,7 +5568,7 @@ switch (yykind)
     /// Constants.
     enum
     {
-      yylast_ = 3561,     ///< Last index in yytable_.
+      yylast_ = 3635,     ///< Last index in yytable_.
       yynnts_ = 101,  ///< Number of nonterminal symbols.
       yyfinal_ = 27 ///< Termination state number.
     };