diff --git a/ccl/core/src/ops/RSOperations.cpp b/ccl/core/src/ops/RSOperations.cpp
index 91e7e69..12d4aa0 100644
--- a/ccl/core/src/ops/RSOperations.cpp
+++ b/ccl/core/src/ops/RSOperations.cpp
@@ -398,15 +398,15 @@ void OpRelativation::ModifyExpressions() {
                                        termID,        // 1
                                        baseName,      // 2
                                        updated,        // 3
-                                       Token::Str(TokenID::PUNC_ITERATE), // 4
-                                       Token::Str(TokenID::PUNC_ASSIGN)); // 5
+                                       Token::Str(TokenID::ITERATE), // 4
+                                       Token::Str(TokenID::ASSIGN)); // 5
 #else
       std::string newExpression = "I{(";
       newExpression += baseID + ", " + termID;
       newExpression += ") | ";
-      newExpression += baseID + Token::Str(TokenID::PUNC_ITERATE) + baseName;
+      newExpression += baseID + Token::Str(TokenID::ITERATE) + baseName;
       newExpression += "; ";
-      newExpression += termID + Token::Str(TokenID::PUNC_ASSIGN) + updated + "}";
+      newExpression += termID + Token::Str(TokenID::ASSIGN) + updated + "}";
 #endif
       resultSchema->SetExpressionFor(entity, newExpression);
       break;
diff --git a/ccl/rslang/header/ASTNormalizer.h b/ccl/rslang/header/ASTNormalizer.h
index 63ed793..f059efd 100644
--- a/ccl/rslang/header/ASTNormalizer.h
+++ b/ccl/rslang/header/ASTNormalizer.h
@@ -10,14 +10,14 @@ class Normalizer {
 public:
   using TupleSubstitutes = std::unordered_map<std::string, std::vector<Index>>;
   using NodeSubstitutes = std::unordered_map<std::string, const SyntaxTree::Node*>;
+  using NameSubstitutes = std::unordered_map<std::string, std::string>;
 
 private:
   SyntaxTreeContext termFuncs;
 
-  TupleSubstitutes tuples{};
-  NodeSubstitutes nodes{};
-
-  std::unordered_map<std::string, std::string> nameSubstitutes{};
+  TupleSubstitutes tupleSubstitutes{};
+  NodeSubstitutes nodeSubstitutes{};
+  NameSubstitutes nameSubstitutes{};
   uint32_t localVarBase{ 0 };
 
 public:
@@ -29,14 +29,17 @@ public:
 
 private:
   void Quantifier(SyntaxTree::Node& quant);
+  void Imperative(SyntaxTree::Node& root);
+  void Recursion(SyntaxTree::Node& root);
+  void Declarative(SyntaxTree::Node& root);
+  void Function(SyntaxTree::Node& func);
+
   static void EnumDeclaration(SyntaxTree::Node& quant);
   void TupleDeclaration(SyntaxTree::Node& declaration, SyntaxTree::Node& predicate);
-  void TupleDeclaration(SyntaxTree::Node& target);
 
-  [[nodiscard]] std::string CreateTupleName(const SyntaxTree::Node& root);
+  [[nodiscard]] std::string ProcessTupleDeclaration(SyntaxTree::Node& root);
   void SubstituteTupleVariables(SyntaxTree::Node& target, const std::string& newName);
-
-  void Function(SyntaxTree::Node& func);
+  
   [[nodiscard]] static std::vector<std::string> ArgNames(const SyntaxTree::Node& declaration);
   void SubstituteArgs(SyntaxTree::Node& target, StrRange pos);
 };
diff --git a/ccl/rslang/header/AsciiLexerImpl.hpp b/ccl/rslang/header/AsciiLexerImpl.hpp
index 54865a6..c4f4bfd 100644
--- a/ccl/rslang/header/AsciiLexerImpl.hpp
+++ b/ccl/rslang/header/AsciiLexerImpl.hpp
@@ -1,6 +1,6 @@
-// AsciiLexerImpl.hpp generated by reflex 4.2.0 from AsciiLexerImpl.l
+// AsciiLexerImpl.hpp generated by reflex 4.2.1 from AsciiLexerImpl.l
 
-#define REFLEX_VERSION "4.2.0"
+#define REFLEX_VERSION "4.2.1"
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                                                            //
@@ -76,8 +76,10 @@ class AsciiLexerImpl : public reflex::AbstractLexer<reflex::Matcher> {
 public:
   [[nodiscard]] StrRange Range() const {
    // Note: returning byte position, not code point! Assume input is ASCII
-    return StrRange{ static_cast<StrPos>(matcher().first()),
-            static_cast<StrPos>(matcher().last()) };
+    return StrRange{
+        static_cast<StrPos>(matcher().first()),
+        static_cast<StrPos>(matcher().last())
+    };
   }
 
  public:
@@ -152,196 +154,196 @@ ccl::rslang::TokenID ccl::rslang::detail::asciilex::AsciiLexerImpl::lex(void)
               return ccl::rslang::TokenID();
             }
             break;
-          case 1: // rule AsciiLexerImpl.l:45: "\A" :
+          case 1: // rule AsciiLexerImpl.l:47: "\A" :
 { return TokenID::FORALL; }
             break;
-          case 2: // rule AsciiLexerImpl.l:46: "\E" :
+          case 2: // rule AsciiLexerImpl.l:48: "\E" :
 { return TokenID::EXISTS; }
 
             break;
-          case 3: // rule AsciiLexerImpl.l:48: "\neg" :
+          case 3: // rule AsciiLexerImpl.l:50: "\neg" :
 { return TokenID::NOT; }
             break;
-          case 4: // rule AsciiLexerImpl.l:49: "\and" :
+          case 4: // rule AsciiLexerImpl.l:51: "\and" :
 { return TokenID::AND; }
             break;
-          case 5: // rule AsciiLexerImpl.l:50: "\or" :
+          case 5: // rule AsciiLexerImpl.l:52: "\or" :
 { return TokenID::OR; }
             break;
-          case 6: // rule AsciiLexerImpl.l:51: "\impl" :
+          case 6: // rule AsciiLexerImpl.l:53: "\impl" :
 { return TokenID::IMPLICATION; }
             break;
-          case 7: // rule AsciiLexerImpl.l:52: "\equiv" :
+          case 7: // rule AsciiLexerImpl.l:54: "\equiv" :
 { return TokenID::EQUIVALENT; }
 
             break;
-          case 8: // rule AsciiLexerImpl.l:54: "\plus" :
+          case 8: // rule AsciiLexerImpl.l:56: "\plus" :
 { return TokenID::PLUS; }
             break;
-          case 9: // rule AsciiLexerImpl.l:55: "\minus" :
+          case 9: // rule AsciiLexerImpl.l:57: "\minus" :
 { return TokenID::MINUS; }
             break;
-          case 10: // rule AsciiLexerImpl.l:56: "\multiply" :
+          case 10: // rule AsciiLexerImpl.l:58: "\multiply" :
 { return TokenID::MULTIPLY; }
             break;
-          case 11: // rule AsciiLexerImpl.l:57: "\gr" :
+          case 11: // rule AsciiLexerImpl.l:59: "\gr" :
 { return TokenID::GREATER; }
             break;
-          case 12: // rule AsciiLexerImpl.l:58: "\ls" :
+          case 12: // rule AsciiLexerImpl.l:60: "\ls" :
 { return TokenID::LESSER; }
             break;
-          case 13: // rule AsciiLexerImpl.l:59: "\ge" :
+          case 13: // rule AsciiLexerImpl.l:61: "\ge" :
 { return TokenID::GREATER_OR_EQ; }
             break;
-          case 14: // rule AsciiLexerImpl.l:60: "\le" :
+          case 14: // rule AsciiLexerImpl.l:62: "\le" :
 { return TokenID::LESSER_OR_EQ; }
 
             break;
-          case 15: // rule AsciiLexerImpl.l:62: "\eq" :
+          case 15: // rule AsciiLexerImpl.l:64: "\eq" :
 { return TokenID::EQUAL; }
             break;
-          case 16: // rule AsciiLexerImpl.l:63: "\noteq" :
+          case 16: // rule AsciiLexerImpl.l:65: "\noteq" :
 { return TokenID::NOTEQUAL; }
 
             break;
-          case 17: // rule AsciiLexerImpl.l:65: "\in" :
+          case 17: // rule AsciiLexerImpl.l:67: "\in" :
 { return TokenID::IN; }
             break;
-          case 18: // rule AsciiLexerImpl.l:66: "\notin" :
+          case 18: // rule AsciiLexerImpl.l:68: "\notin" :
 { return TokenID::NOTIN; }
             break;
-          case 19: // rule AsciiLexerImpl.l:67: "\subseteq" :
+          case 19: // rule AsciiLexerImpl.l:69: "\subseteq" :
 { return TokenID::SUBSET_OR_EQ; }
             break;
-          case 20: // rule AsciiLexerImpl.l:68: "\subset" :
+          case 20: // rule AsciiLexerImpl.l:70: "\subset" :
 { return TokenID::SUBSET; }
             break;
-          case 21: // rule AsciiLexerImpl.l:69: "\notsubset" :
+          case 21: // rule AsciiLexerImpl.l:71: "\notsubset" :
 { return TokenID::NOTSUBSET; }
 
             break;
-          case 22: // rule AsciiLexerImpl.l:71: "*" :
+          case 22: // rule AsciiLexerImpl.l:73: "*" :
 { return TokenID::DECART; }
             break;
-          case 23: // rule AsciiLexerImpl.l:72: "\union" :
+          case 23: // rule AsciiLexerImpl.l:74: "\union" :
 { return TokenID::UNION; }
             break;
-          case 24: // rule AsciiLexerImpl.l:73: "\intersect" :
+          case 24: // rule AsciiLexerImpl.l:75: "\intersect" :
 { return TokenID::INTERSECTION; }
             break;
-          case 25: // rule AsciiLexerImpl.l:74: "\setminus" :
+          case 25: // rule AsciiLexerImpl.l:76: "\setminus" :
 { return TokenID::SET_MINUS; }
             break;
-          case 26: // rule AsciiLexerImpl.l:75: "\symmdiff" :
+          case 26: // rule AsciiLexerImpl.l:77: "\symmdiff" :
 { return TokenID::SYMMINUS; }
             break;
-          case 27: // rule AsciiLexerImpl.l:76: "B" :
+          case 27: // rule AsciiLexerImpl.l:78: "B" :
 { return TokenID::BOOLEAN; }
 
             break;
-          case 28: // rule AsciiLexerImpl.l:78: pr{index} :
+          case 28: // rule AsciiLexerImpl.l:80: pr{index} :
 { return TokenID::SMALLPR; }
             break;
-          case 29: // rule AsciiLexerImpl.l:79: Pr{index} :
+          case 29: // rule AsciiLexerImpl.l:81: Pr{index} :
 { return TokenID::BIGPR; }
             break;
-          case 30: // rule AsciiLexerImpl.l:80: Fi{index} :
+          case 30: // rule AsciiLexerImpl.l:82: Fi{index} :
 { return TokenID::FILTER; }
             break;
-          case 31: // rule AsciiLexerImpl.l:81: card :
+          case 31: // rule AsciiLexerImpl.l:83: card :
 { return TokenID::CARD; }
             break;
-          case 32: // rule AsciiLexerImpl.l:82: bool :
+          case 32: // rule AsciiLexerImpl.l:84: bool :
 { return TokenID::BOOL; }
             break;
-          case 33: // rule AsciiLexerImpl.l:83: red :
+          case 33: // rule AsciiLexerImpl.l:85: red :
 { return TokenID::REDUCE; }
             break;
-          case 34: // rule AsciiLexerImpl.l:84: debool :
+          case 34: // rule AsciiLexerImpl.l:86: debool :
 { return TokenID::DEBOOL; }
 
             break;
-          case 35: // rule AsciiLexerImpl.l:86: D :
+          case 35: // rule AsciiLexerImpl.l:88: D :
 { return TokenID::DECLARATIVE; }
             break;
-          case 36: // rule AsciiLexerImpl.l:87: R :
+          case 36: // rule AsciiLexerImpl.l:89: R :
 { return TokenID::RECURSIVE; }
             break;
-          case 37: // rule AsciiLexerImpl.l:88: I :
+          case 37: // rule AsciiLexerImpl.l:90: I :
 { return TokenID::IMPERATIVE; }
 
             break;
-          case 38: // rule AsciiLexerImpl.l:90: Z :
+          case 38: // rule AsciiLexerImpl.l:92: Z :
 { return TokenID::LIT_INTSET; }
             break;
-          case 39: // rule AsciiLexerImpl.l:91: "{}" :
+          case 39: // rule AsciiLexerImpl.l:93: "{}" :
 { return TokenID::LIT_EMPTYSET; }
             break;
-          case 40: // rule AsciiLexerImpl.l:92: {number} :
+          case 40: // rule AsciiLexerImpl.l:94: {number} :
 { return TokenID::LIT_INTEGER; }
 
             break;
-          case 41: // rule AsciiLexerImpl.l:94: F{number} :
+          case 41: // rule AsciiLexerImpl.l:96: F{number} :
 { return TokenID::ID_FUNCTION; }
             break;
-          case 42: // rule AsciiLexerImpl.l:95: P{number} :
+          case 42: // rule AsciiLexerImpl.l:97: P{number} :
 { return TokenID::ID_PREDICATE; }
             break;
-          case 43: // rule AsciiLexerImpl.l:96: R{number} :
+          case 43: // rule AsciiLexerImpl.l:98: R{number} :
 { return TokenID::ID_RADICAL; }
 
             break;
-          case 44: // rule AsciiLexerImpl.l:98: {global_id} :
+          case 44: // rule AsciiLexerImpl.l:100: {global_id} :
 { return TokenID::ID_GLOBAL; }
             break;
-          case 45: // rule AsciiLexerImpl.l:99: {local_id} :
+          case 45: // rule AsciiLexerImpl.l:101: {local_id} :
 { return TokenID::ID_LOCAL; }
 
             break;
-          case 46: // rule AsciiLexerImpl.l:101: "\assign" :
-{ return TokenID::PUNC_ASSIGN; }
+          case 46: // rule AsciiLexerImpl.l:103: "\assign" :
+{ return TokenID::ASSIGN; }
             break;
-          case 47: // rule AsciiLexerImpl.l:102: "\from" :
-{ return TokenID::PUNC_ITERATE; }
+          case 47: // rule AsciiLexerImpl.l:104: "\from" :
+{ return TokenID::ITERATE; }
             break;
-          case 48: // rule AsciiLexerImpl.l:103: "\defexpr" :
+          case 48: // rule AsciiLexerImpl.l:105: "\defexpr" :
 { return TokenID::PUNC_DEFINE; }
             break;
-          case 49: // rule AsciiLexerImpl.l:104: "\deftype" :
+          case 49: // rule AsciiLexerImpl.l:106: "\deftype" :
 { return TokenID::PUNC_STRUCT; }
             break;
-          case 50: // rule AsciiLexerImpl.l:105: "(" :
+          case 50: // rule AsciiLexerImpl.l:107: "(" :
 { return TokenID::PUNC_PL; }
             break;
-          case 51: // rule AsciiLexerImpl.l:106: ")" :
+          case 51: // rule AsciiLexerImpl.l:108: ")" :
 { return TokenID::PUNC_PR; }
             break;
-          case 52: // rule AsciiLexerImpl.l:107: "{" :
+          case 52: // rule AsciiLexerImpl.l:109: "{" :
 { return TokenID::PUNC_CL; }
             break;
-          case 53: // rule AsciiLexerImpl.l:108: "}" :
+          case 53: // rule AsciiLexerImpl.l:110: "}" :
 { return TokenID::PUNC_CR; }
             break;
-          case 54: // rule AsciiLexerImpl.l:109: "[" :
+          case 54: // rule AsciiLexerImpl.l:111: "[" :
 { return TokenID::PUNC_SL; }
             break;
-          case 55: // rule AsciiLexerImpl.l:110: "]" :
+          case 55: // rule AsciiLexerImpl.l:112: "]" :
 { return TokenID::PUNC_SR; }
             break;
-          case 56: // rule AsciiLexerImpl.l:111: "|" :
+          case 56: // rule AsciiLexerImpl.l:113: "|" :
 { return TokenID::PUNC_BAR; }
             break;
-          case 57: // rule AsciiLexerImpl.l:112: "," :
+          case 57: // rule AsciiLexerImpl.l:114: "," :
 { return TokenID::PUNC_COMMA; }
             break;
-          case 58: // rule AsciiLexerImpl.l:113: ";" :
+          case 58: // rule AsciiLexerImpl.l:115: ";" :
 { return TokenID::PUNC_SEMICOLON; }
 
             break;
-          case 59: // rule AsciiLexerImpl.l:115: {ws} :
+          case 59: // rule AsciiLexerImpl.l:117: {ws} :
 ;
             break;
-          case 60: // rule AsciiLexerImpl.l:117: . :
+          case 60: // rule AsciiLexerImpl.l:119: . :
 { return TokenID::INTERRUPT; }
 
             break;
diff --git a/ccl/rslang/header/GeneratorImplAST.h b/ccl/rslang/header/GeneratorImplAST.h
index ad00f14..dbeff1e 100644
--- a/ccl/rslang/header/GeneratorImplAST.h
+++ b/ccl/rslang/header/GeneratorImplAST.h
@@ -41,16 +41,15 @@ private:
   bool ViQuantifier(Cursor iter);
   bool ViNegation(Cursor iter);
   bool ViLogicBinary(Cursor iter);
-  bool ViEquals(Cursor iter);
-  bool ViIntegerPredicate(Cursor iter) { return ViEquals(iter); }
-  bool ViSetexprPredicate(Cursor iter) { return ViEquals(iter); }
+  bool ViEquals(Cursor iter) { return OutputBinary(iter); }
+  bool ViIntegerPredicate(Cursor iter) { return OutputBinary(iter); }
+  bool ViSetexprPredicate(Cursor iter) { return OutputBinary(iter); }
 
   bool ViDeclarative(Cursor iter);
-  bool ViImperative(Cursor iter);
-  bool ViImpDeclare(Cursor iter);
-  bool ViImpAssign(Cursor iter);
-  bool ViImpCheck(Cursor iter);
   bool ViRecursion(Cursor iter);
+  bool ViImperative(Cursor iter);
+  bool ViIterate(Cursor iter) { return OutputBinary(iter); }
+  bool ViAssign(Cursor iter) { return OutputBinary(iter); }
 
   bool ViDecart(Cursor iter);
   bool ViBoolean(Cursor iter);
@@ -71,9 +70,10 @@ private:
   void Clear() noexcept;
 
   void OutputChild(const Cursor& iter, Index index, bool addBrackets = false);
+  bool OutputBinary(const Cursor& iter);
 
-  void EnumChildren(const Cursor& iter, const std::string& separator);
-  void EnumChildren(const Cursor& iter, char left, char right, const std::string& separator);
+  bool EnumChildren(const Cursor& iter, const std::string& separator);
+  bool EnumChildren(const Cursor& iter, char left, char right, const std::string& separator);
 };
 
 } // namespace ccl::rslang
\ No newline at end of file
diff --git a/ccl/rslang/header/MathLexerImpl.hpp b/ccl/rslang/header/MathLexerImpl.hpp
index b5b26c0..05a9f5c 100644
--- a/ccl/rslang/header/MathLexerImpl.hpp
+++ b/ccl/rslang/header/MathLexerImpl.hpp
@@ -1,6 +1,6 @@
-// MathLexerImpl.hpp generated by reflex 4.2.0 from MathLexerImpl.l
+// MathLexerImpl.hpp generated by reflex 4.2.1 from MathLexerImpl.l
 
-#define REFLEX_VERSION "4.2.0"
+#define REFLEX_VERSION "4.2.1"
 
 ////////////////////////////////////////////////////////////////////////////////
 //                                                                            //
@@ -81,8 +81,10 @@ public:
   StrPos lineBase{ 0 };
 
   [[nodiscard]] StrRange Range() const {
-    return StrRange{ static_cast<StrPos>(lineBase + columno()),
-            static_cast<StrPos>(lineBase + columno() + columns()) };
+    return StrRange{
+        static_cast<StrPos>(lineBase + columno()),
+        static_cast<StrPos>(lineBase + columno() + columns())
+    };
   }
 
 
@@ -158,199 +160,199 @@ ccl::rslang::TokenID ccl::rslang::detail::rslex::MathLexerImpl::lex(void)
               return ccl::rslang::TokenID();
             }
             break;
-          case 1: // rule MathLexerImpl.l:48: "+" :
+          case 1: // rule MathLexerImpl.l:50: "+" :
 { return TokenID::PLUS; }
             break;
-          case 2: // rule MathLexerImpl.l:49: "-" :
+          case 2: // rule MathLexerImpl.l:51: "-" :
 { return TokenID::MINUS; }
             break;
-          case 3: // rule MathLexerImpl.l:50: "*" :
+          case 3: // rule MathLexerImpl.l:52: "*" :
 { return TokenID::MULTIPLY; }
             break;
-          case 4: // rule MathLexerImpl.l:51: ">" :
+          case 4: // rule MathLexerImpl.l:53: ">" :
 { return TokenID::GREATER; }
             break;
-          case 5: // rule MathLexerImpl.l:52: "<" :
+          case 5: // rule MathLexerImpl.l:54: "<" :
 { return TokenID::LESSER; }
             break;
-          case 6: // rule MathLexerImpl.l:53: \x{2265} :
+          case 6: // rule MathLexerImpl.l:55: \x{2265} :
 { return TokenID::GREATER_OR_EQ; }
             break;
-          case 7: // rule MathLexerImpl.l:54: \x{2264} :
+          case 7: // rule MathLexerImpl.l:56: \x{2264} :
 { return TokenID::LESSER_OR_EQ; }
 
             break;
-          case 8: // rule MathLexerImpl.l:56: "=" :
+          case 8: // rule MathLexerImpl.l:58: "=" :
 { return TokenID::EQUAL; }
             break;
-          case 9: // rule MathLexerImpl.l:57: \x{2260} :
+          case 9: // rule MathLexerImpl.l:59: \x{2260} :
 { return TokenID::NOTEQUAL; }
 
             break;
-          case 10: // rule MathLexerImpl.l:59: \x{2200} :
+          case 10: // rule MathLexerImpl.l:61: \x{2200} :
 { return TokenID::FORALL; }
             break;
-          case 11: // rule MathLexerImpl.l:60: \x{2203} :
+          case 11: // rule MathLexerImpl.l:62: \x{2203} :
 { return TokenID::EXISTS; }
 
             break;
-          case 12: // rule MathLexerImpl.l:62: \x{00AC} :
+          case 12: // rule MathLexerImpl.l:64: \x{00AC} :
 { return TokenID::NOT; }
             break;
-          case 13: // rule MathLexerImpl.l:63: "&" :
+          case 13: // rule MathLexerImpl.l:65: "&" :
 { return TokenID::AND; }
             break;
-          case 14: // rule MathLexerImpl.l:64: \x{2228} :
+          case 14: // rule MathLexerImpl.l:66: \x{2228} :
 { return TokenID::OR; }
             break;
-          case 15: // rule MathLexerImpl.l:65: \x{21D2} :
+          case 15: // rule MathLexerImpl.l:67: \x{21D2} :
 { return TokenID::IMPLICATION; }
             break;
-          case 16: // rule MathLexerImpl.l:66: \x{21D4} :
+          case 16: // rule MathLexerImpl.l:68: \x{21D4} :
 { return TokenID::EQUIVALENT; }
 
             break;
-          case 17: // rule MathLexerImpl.l:68: :\x{2208} :
-{ return TokenID::PUNC_ITERATE; }
+          case 17: // rule MathLexerImpl.l:70: :\x{2208} :
+{ return TokenID::ITERATE; }
             break;
-          case 18: // rule MathLexerImpl.l:69: \x{2208} :
+          case 18: // rule MathLexerImpl.l:71: \x{2208} :
 { return TokenID::IN; }
             break;
-          case 19: // rule MathLexerImpl.l:70: \x{2209} :
+          case 19: // rule MathLexerImpl.l:72: \x{2209} :
 { return TokenID::NOTIN; }
             break;
-          case 20: // rule MathLexerImpl.l:71: \x{2286} :
+          case 20: // rule MathLexerImpl.l:73: \x{2286} :
 { return TokenID::SUBSET_OR_EQ; }
             break;
-          case 21: // rule MathLexerImpl.l:72: \x{2282} :
+          case 21: // rule MathLexerImpl.l:74: \x{2282} :
 { return TokenID::SUBSET; }
             break;
-          case 22: // rule MathLexerImpl.l:73: \x{2284} :
+          case 22: // rule MathLexerImpl.l:75: \x{2284} :
 { return TokenID::NOTSUBSET; }
 
             break;
-          case 23: // rule MathLexerImpl.l:75: \x{00D7} :
+          case 23: // rule MathLexerImpl.l:77: \x{00D7} :
 { return TokenID::DECART; }
             break;
-          case 24: // rule MathLexerImpl.l:76: \x{222A} :
+          case 24: // rule MathLexerImpl.l:78: \x{222A} :
 { return TokenID::UNION; }
             break;
-          case 25: // rule MathLexerImpl.l:77: \x{2229} :
+          case 25: // rule MathLexerImpl.l:79: \x{2229} :
 { return TokenID::INTERSECTION; }
             break;
-          case 26: // rule MathLexerImpl.l:78: \x{005C} :
+          case 26: // rule MathLexerImpl.l:80: \x{005C} :
 { return TokenID::SET_MINUS; }
             break;
-          case 27: // rule MathLexerImpl.l:79: \x{2206} :
+          case 27: // rule MathLexerImpl.l:81: \x{2206} :
 { return TokenID::SYMMINUS; }
             break;
-          case 28: // rule MathLexerImpl.l:80: \x{212C} :
+          case 28: // rule MathLexerImpl.l:82: \x{212C} :
 { return TokenID::BOOLEAN; }
 
             break;
-          case 29: // rule MathLexerImpl.l:82: pr{index} :
+          case 29: // rule MathLexerImpl.l:84: pr{index} :
 { return TokenID::SMALLPR; }
             break;
-          case 30: // rule MathLexerImpl.l:83: Pr{index} :
+          case 30: // rule MathLexerImpl.l:85: Pr{index} :
 { return TokenID::BIGPR; }
             break;
-          case 31: // rule MathLexerImpl.l:84: Fi{index} :
+          case 31: // rule MathLexerImpl.l:86: Fi{index} :
 { return TokenID::FILTER; }
             break;
-          case 32: // rule MathLexerImpl.l:85: card :
+          case 32: // rule MathLexerImpl.l:87: card :
 { return TokenID::CARD; }
             break;
-          case 33: // rule MathLexerImpl.l:86: bool :
+          case 33: // rule MathLexerImpl.l:88: bool :
 { return TokenID::BOOL; }
             break;
-          case 34: // rule MathLexerImpl.l:87: red :
+          case 34: // rule MathLexerImpl.l:89: red :
 { return TokenID::REDUCE; }
             break;
-          case 35: // rule MathLexerImpl.l:88: debool :
+          case 35: // rule MathLexerImpl.l:90: debool :
 { return TokenID::DEBOOL; }
 
             break;
-          case 36: // rule MathLexerImpl.l:90: D :
+          case 36: // rule MathLexerImpl.l:92: D :
 { return TokenID::DECLARATIVE; }
             break;
-          case 37: // rule MathLexerImpl.l:91: R :
+          case 37: // rule MathLexerImpl.l:93: R :
 { return TokenID::RECURSIVE; }
             break;
-          case 38: // rule MathLexerImpl.l:92: I :
+          case 38: // rule MathLexerImpl.l:94: I :
 { return TokenID::IMPERATIVE; }
 
             break;
-          case 39: // rule MathLexerImpl.l:94: Z :
+          case 39: // rule MathLexerImpl.l:96: Z :
 { return TokenID::LIT_INTSET; }
             break;
-          case 40: // rule MathLexerImpl.l:95: \x{2205} :
+          case 40: // rule MathLexerImpl.l:97: \x{2205} :
 { return TokenID::LIT_EMPTYSET; }
             break;
-          case 41: // rule MathLexerImpl.l:96: {number} :
+          case 41: // rule MathLexerImpl.l:98: {number} :
 { return TokenID::LIT_INTEGER; }
 
             break;
-          case 42: // rule MathLexerImpl.l:98: F{number} :
+          case 42: // rule MathLexerImpl.l:100: F{number} :
 { return TokenID::ID_FUNCTION; }
             break;
-          case 43: // rule MathLexerImpl.l:99: P{number} :
+          case 43: // rule MathLexerImpl.l:101: P{number} :
 { return TokenID::ID_PREDICATE; }
             break;
-          case 44: // rule MathLexerImpl.l:100: R{number} :
+          case 44: // rule MathLexerImpl.l:102: R{number} :
 { return TokenID::ID_RADICAL; }
 
             break;
-          case 45: // rule MathLexerImpl.l:102: {global_id} :
+          case 45: // rule MathLexerImpl.l:104: {global_id} :
 { return TokenID::ID_GLOBAL; }
             break;
-          case 46: // rule MathLexerImpl.l:103: {local_id} :
+          case 46: // rule MathLexerImpl.l:105: {local_id} :
 { return TokenID::ID_LOCAL; }
 
             break;
-          case 47: // rule MathLexerImpl.l:105: ":=" :
-{ return TokenID::PUNC_ASSIGN; }
+          case 47: // rule MathLexerImpl.l:107: ":=" :
+{ return TokenID::ASSIGN; }
             break;
-          case 48: // rule MathLexerImpl.l:106: ":==" :
+          case 48: // rule MathLexerImpl.l:108: ":==" :
 { return TokenID::PUNC_DEFINE; }
             break;
-          case 49: // rule MathLexerImpl.l:107: "::=" :
+          case 49: // rule MathLexerImpl.l:109: "::=" :
 { return TokenID::PUNC_STRUCT; }
             break;
-          case 50: // rule MathLexerImpl.l:108: "(" :
+          case 50: // rule MathLexerImpl.l:110: "(" :
 { return TokenID::PUNC_PL; }
             break;
-          case 51: // rule MathLexerImpl.l:109: ")" :
+          case 51: // rule MathLexerImpl.l:111: ")" :
 { return TokenID::PUNC_PR; }
             break;
-          case 52: // rule MathLexerImpl.l:110: "{" :
+          case 52: // rule MathLexerImpl.l:112: "{" :
 { return TokenID::PUNC_CL; }
             break;
-          case 53: // rule MathLexerImpl.l:111: "}" :
+          case 53: // rule MathLexerImpl.l:113: "}" :
 { return TokenID::PUNC_CR; }
             break;
-          case 54: // rule MathLexerImpl.l:112: "[" :
+          case 54: // rule MathLexerImpl.l:114: "[" :
 { return TokenID::PUNC_SL; }
             break;
-          case 55: // rule MathLexerImpl.l:113: "]" :
+          case 55: // rule MathLexerImpl.l:115: "]" :
 { return TokenID::PUNC_SR; }
             break;
-          case 56: // rule MathLexerImpl.l:114: "|" :
+          case 56: // rule MathLexerImpl.l:116: "|" :
 { return TokenID::PUNC_BAR; }
             break;
-          case 57: // rule MathLexerImpl.l:115: "," :
+          case 57: // rule MathLexerImpl.l:117: "," :
 { return TokenID::PUNC_COMMA; }
             break;
-          case 58: // rule MathLexerImpl.l:116: ";" :
+          case 58: // rule MathLexerImpl.l:118: ";" :
 { return TokenID::PUNC_SEMICOLON; }
 
             break;
-          case 59: // rule MathLexerImpl.l:118: \n :
+          case 59: // rule MathLexerImpl.l:120: \n :
 { lineBase += static_cast<StrPos>(columno() + 1); }
             break;
-          case 60: // rule MathLexerImpl.l:119: [ \t]+ :
+          case 60: // rule MathLexerImpl.l:121: [ \t]+ :
 ;
             break;
-          case 61: // rule MathLexerImpl.l:121: . :
+          case 61: // rule MathLexerImpl.l:123: . :
 { return TokenID::INTERRUPT; }
 
             break;
diff --git a/ccl/rslang/header/RSParserImpl.h b/ccl/rslang/header/RSParserImpl.h
index bd0fe0f..59ff0ae 100644
--- a/ccl/rslang/header/RSParserImpl.h
+++ b/ccl/rslang/header/RSParserImpl.h
@@ -87,8 +87,8 @@ RawNode FunctionDeclaration(
 
 RawNode FunctionCall(
     RawNode function,
-    RawNode args, RawNode
-    rs
+    RawNode args,
+    RawNode rs
 );
 
 RawNode FilterCall(
@@ -109,7 +109,12 @@ RawNode TermDeclaration(
     RawNode declaration,
     RawNode domain,
     RawNode predicate,
-    RawNode rc);
+    RawNode rc
+);
+RawNode TupleDeclaration(
+    ParserState* state,
+    RawNode tuple
+);
 
 RawNode FullRecursion(
     RawNode rec,
@@ -137,7 +142,7 @@ RawNode Imperative(
 
 } // namespace ccl::rslang::detail
 
-#line 141 "../header/RSParserImpl.h"
+#line 146 "../header/RSParserImpl.h"
 
 # include <cassert>
 # include <cstdlib> // std::abort
@@ -267,7 +272,7 @@ RawNode Imperative(
 
 #line 15 "RSParserImpl.y"
 namespace ccl { namespace rslang { namespace detail {
-#line 271 "../header/RSParserImpl.h"
+#line 276 "../header/RSParserImpl.h"
 
 
 
@@ -351,10 +356,10 @@ namespace ccl { namespace rslang { namespace detail {
     RST_DECLARATIVE = 300,         // DECLARATIVE
     RST_RECURSIVE = 301,           // RECURSIVE
     RST_IMPERATIVE = 302,          // IMPERATIVE
-    RST_DEFINE = 303,              // DEFINE
-    RST_STRUCT = 304,              // STRUCT
-    RST_ASSIGN = 305,              // ASSIGN
-    RST_ITERATE = 306,             // ITERATE
+    RST_ITERATE = 303,             // ITERATE
+    RST_ASSIGN = 304,              // ASSIGN
+    RST_DEFINE = 305,              // DEFINE
+    RST_STRUCT = 306,              // STRUCT
     RST_LP = 307,                  // LP
     RST_RP = 308,                  // RP
     RST_LC = 309,                  // LC
@@ -430,10 +435,10 @@ namespace ccl { namespace rslang { namespace detail {
         S_DECLARATIVE = 45,                      // DECLARATIVE
         S_RECURSIVE = 46,                        // RECURSIVE
         S_IMPERATIVE = 47,                       // IMPERATIVE
-        S_DEFINE = 48,                           // DEFINE
-        S_STRUCT = 49,                           // STRUCT
-        S_ASSIGN = 50,                           // ASSIGN
-        S_ITERATE = 51,                          // ITERATE
+        S_ITERATE = 48,                          // ITERATE
+        S_ASSIGN = 49,                           // ASSIGN
+        S_DEFINE = 50,                           // DEFINE
+        S_STRUCT = 51,                           // STRUCT
         S_LP = 52,                               // LP
         S_RP = 53,                               // RP
         S_LC = 54,                               // LC
@@ -451,38 +456,34 @@ namespace ccl { namespace rslang { namespace detail {
         S_arguments = 66,                        // arguments
         S_declaration = 67,                      // declaration
         S_variable = 68,                         // variable
-        S_var_enum = 69,                         // var_enum
-        S_var_all = 70,                          // var_all
-        S_logic = 71,                            // logic
+        S_variable_pack = 69,                    // variable_pack
+        S_logic = 70,                            // logic
+        S_logic_no_binary = 71,                  // logic_no_binary
         S_logic_all = 72,                        // logic_all
         S_logic_par = 73,                        // logic_par
         S_logic_predicates = 74,                 // logic_predicates
         S_binary_predicate = 75,                 // binary_predicate
         S_logic_unary = 76,                      // logic_unary
-        S_logic_no_binary = 77,                  // logic_no_binary
-        S_quantifier = 78,                       // quantifier
-        S_quant_var = 79,                        // quant_var
-        S_quant_var_enum = 80,                   // quant_var_enum
-        S_logic_binary = 81,                     // logic_binary
-        S_setexpr = 82,                          // setexpr
-        S_text_function = 83,                    // text_function
-        S_setexpr_enum = 84,                     // setexpr_enum
-        S_setexpr_enum_min2 = 85,                // setexpr_enum_min2
-        S_literal = 86,                          // literal
-        S_identifier = 87,                       // identifier
-        S_setexpr_binary = 88,                   // setexpr_binary
-        S_setexpr_generators = 89,               // setexpr_generators
-        S_enumeration = 90,                      // enumeration
-        S_tuple = 91,                            // tuple
-        S_boolean = 92,                          // boolean
-        S_filter_expression = 93,                // filter_expression
-        S_declarative = 94,                      // declarative
-        S_recursion = 95,                        // recursion
-        S_imperative = 96,                       // imperative
-        S_imp_blocks = 97,                       // imp_blocks
-        S_imp_block = 98,                        // imp_block
-        S_RPE = 99,                              // RPE
-        S_RCE = 100                              // RCE
+        S_quantifier = 77,                       // quantifier
+        S_logic_binary = 78,                     // logic_binary
+        S_setexpr = 79,                          // setexpr
+        S_text_function = 80,                    // text_function
+        S_setexpr_enum = 81,                     // setexpr_enum
+        S_setexpr_enum_min2 = 82,                // setexpr_enum_min2
+        S_literal = 83,                          // literal
+        S_identifier = 84,                       // identifier
+        S_setexpr_binary = 85,                   // setexpr_binary
+        S_setexpr_generators = 86,               // setexpr_generators
+        S_enumeration = 87,                      // enumeration
+        S_tuple = 88,                            // tuple
+        S_boolean = 89,                          // boolean
+        S_filter_expression = 90,                // filter_expression
+        S_declarative = 91,                      // declarative
+        S_recursion = 92,                        // recursion
+        S_imperative = 93,                       // imperative
+        S_imp_blocks = 94,                       // imp_blocks
+        S_RPE = 95,                              // RPE
+        S_RCE = 96                               // RCE
       };
     };
 
@@ -980,9 +981,9 @@ namespace ccl { namespace rslang { namespace detail {
     /// Constants.
     enum
     {
-      yylast_ = 640,     ///< Last index in yytable_.
-      yynnts_ = 40,  ///< Number of nonterminal symbols.
-      yyfinal_ = 87 ///< Termination state number.
+      yylast_ = 620,     ///< Last index in yytable_.
+      yynnts_ = 36,  ///< Number of nonterminal symbols.
+      yyfinal_ = 89 ///< Termination state number.
     };
 
 
@@ -994,7 +995,7 @@ namespace ccl { namespace rslang { namespace detail {
 
 #line 15 "RSParserImpl.y"
 } } } // ccl::rslang::detail
-#line 998 "../header/RSParserImpl.h"
+#line 999 "../header/RSParserImpl.h"
 
 
 
diff --git a/ccl/rslang/include/ccl/rslang/ASTInterpreter.h b/ccl/rslang/include/ccl/rslang/ASTInterpreter.h
index 9f53d78..ed0ea4f 100644
--- a/ccl/rslang/include/ccl/rslang/ASTInterpreter.h
+++ b/ccl/rslang/include/ccl/rslang/ASTInterpreter.h
@@ -81,11 +81,10 @@ protected:
   bool ViBoolean(Cursor iter);
 
   bool ViDeclarative(Cursor iter);
-  bool ViImperative(Cursor iter);
-  //bool ViImpDeclare(Cursor iter);
-  //bool ViImpAssign(Cursor iter);
-  //bool ViImpCheck(Cursor iter);
   bool ViRecursion(Cursor iter);
+  bool ViImperative(Cursor iter);
+  //bool ViIterate(Cursor iter);
+  //bool ViAssign(Cursor iter);
 
   bool ViTuple(Cursor iter);
   bool ViEnumeration(Cursor iter);
diff --git a/ccl/rslang/include/ccl/rslang/LexerBase.hpp b/ccl/rslang/include/ccl/rslang/LexerBase.hpp
index 19f0994..453c5eb 100644
--- a/ccl/rslang/include/ccl/rslang/LexerBase.hpp
+++ b/ccl/rslang/include/ccl/rslang/LexerBase.hpp
@@ -30,8 +30,11 @@ public:
       lex->lex();
       auto token = lex->MakeToken();
       if (token.id == TokenID::INTERRUPT && lex->reporter.has_value()) {
-        lex->reporter.value()(Error{ static_cast<uint32_t>(LexerEID::unknownSymbol),
-                                      token.pos.start, { lex->Text() } });
+        lex->reporter.value()(Error{
+          static_cast<uint32_t>(LexerEID::unknownSymbol),
+          token.pos.start,
+          { lex->Text() }
+        });
       }
       return token;
     };
diff --git a/ccl/rslang/include/ccl/rslang/ParserState.hpp b/ccl/rslang/include/ccl/rslang/ParserState.hpp
index a67ecb9..4bf4544 100644
--- a/ccl/rslang/include/ccl/rslang/ParserState.hpp
+++ b/ccl/rslang/include/ccl/rslang/ParserState.hpp
@@ -57,10 +57,10 @@ public:
     }
   }
 
-  void CreateSyntaxTree(RawNode root);
-  void FinalizeExpression(RawNode expr);
-  void FinalizeCstEmpty(RawNode cst, RawNode mode);
-  void FinalizeCstExpression(RawNode cst, RawNode mode, RawNode data);
+  bool CreateSyntaxTree(RawNode root);
+  bool FinalizeExpression(RawNode expr);
+  bool FinalizeCstEmpty(RawNode cst, RawNode mode);
+  bool FinalizeCstExpression(RawNode cst, RawNode mode, RawNode data);
 };
 
 } // namespace ccl::rslang::detail
\ No newline at end of file
diff --git a/ccl/rslang/include/ccl/rslang/RSErrorCodes.hpp b/ccl/rslang/include/ccl/rslang/RSErrorCodes.hpp
index 78c1a66..f043d5e 100644
--- a/ccl/rslang/include/ccl/rslang/RSErrorCodes.hpp
+++ b/ccl/rslang/include/ccl/rslang/RSErrorCodes.hpp
@@ -17,6 +17,7 @@ enum class ParseEID : uint32_t {
   missingParenthesis = 0x8406,      // Пропущена скобка ')'
   missingCurlyBrace = 0x8407,       // Пропущена скобка '}'
   invalidQuantifier = 0x8408,       // Некорректная кванторная декларация
+  invalidImperative = 0x8409,       // Использование императивного синтаксиса вне императивного блока
   expectedDeclaration = 0x8414,     // Ожидалось объявление аргументов
   expectedLocal = 0x8415,           // Ожидалось имя локальной переменной
 };
diff --git a/ccl/rslang/include/ccl/rslang/RSToken.h b/ccl/rslang/include/ccl/rslang/RSToken.h
index b057608..0798904 100644
--- a/ccl/rslang/include/ccl/rslang/RSToken.h
+++ b/ccl/rslang/include/ccl/rslang/RSToken.h
@@ -82,11 +82,13 @@ enum class TokenID : uint32_t { // NOLINT(performance-enum-size)
   RECURSIVE,
   IMPERATIVE,
 
+  // Imperative operators
+  ITERATE,
+  ASSIGN,
+
   // Punctuation
   PUNC_DEFINE,
   PUNC_STRUCT,
-  PUNC_ASSIGN,
-  PUNC_ITERATE,
   PUNC_PL,
   PUNC_PR,
   PUNC_CL,
@@ -113,10 +115,6 @@ enum class TokenID : uint32_t { // NOLINT(performance-enum-size)
   NT_RECURSIVE_FULL, // Полная рекурсия
   NT_RECURSIVE_SHORT, // Сокращенная рекурсия
 
-  NT_IMP_DECLARE, // Блок декларации
-  NT_IMP_ASSIGN, // Блок присвоения
-  NT_IMP_LOGIC, // Блок проверки
-  
   // ======= Helper tokens ========
   INTERRUPT,
   END,
diff --git a/ccl/rslang/include/ccl/rslang/SyntaxTree.h b/ccl/rslang/include/ccl/rslang/SyntaxTree.h
index 75176a7..3774ade 100644
--- a/ccl/rslang/include/ccl/rslang/SyntaxTree.h
+++ b/ccl/rslang/include/ccl/rslang/SyntaxTree.h
@@ -232,21 +232,19 @@ public:
         assert(ChildrenCount() == 2);
         return visitor.ViSetexprPredicate(*this);
 
+      case TokenID::ITERATE:
+        assert(ChildrenCount() == 2);
+        return visitor.ViIterate(*this);
+      case TokenID::ASSIGN:
+        assert(ChildrenCount() == 2);
+        return visitor.ViAssign(*this);
+
       case TokenID::NT_DECLARATIVE_EXPR:
         assert(ChildrenCount() == 3);
         return visitor.ViDeclarative(*this);
       case TokenID::NT_IMPERATIVE_EXPR:
         assert(ChildrenCount() > 1);
         return visitor.ViImperative(*this);
-      case TokenID::NT_IMP_DECLARE:
-        assert(ChildrenCount() == 2);
-        return visitor.ViImpDeclare(*this);
-      case TokenID::NT_IMP_ASSIGN:
-        assert(ChildrenCount() == 2);
-        return visitor.ViImpAssign(*this);
-      case TokenID::NT_IMP_LOGIC:
-        assert(ChildrenCount() == 1);
-        return visitor.ViImpCheck(*this);
 
       case TokenID::DECART:
         assert(ChildrenCount() > 1);
@@ -349,11 +347,10 @@ private:
   bool ViSetexprPredicate(Cursor iter) { return this->BaseT().VisitDefault(iter); }
 
   bool ViDeclarative(Cursor iter) { return this->BaseT().VisitDefault(iter); }
-  bool ViImperative(Cursor iter) { return this->BaseT().VisitDefault(iter); }
-  bool ViImpDeclare(Cursor iter) { return this->BaseT().VisitDefault(iter); }
-  bool ViImpAssign(Cursor iter) { return this->BaseT().VisitDefault(iter); }
-  bool ViImpCheck(Cursor iter) { return this->BaseT().VisitDefault(iter); }
   bool ViRecursion(Cursor iter) { return this->BaseT().VisitDefault(iter); }
+  bool ViImperative(Cursor iter) { return this->BaseT().VisitDefault(iter); }
+  bool ViIterate(Cursor iter) { return this->BaseT().VisitDefault(iter); }
+  bool ViAssign(Cursor iter) { return this->BaseT().VisitDefault(iter); }
 
   bool ViDecart(Cursor iter) { return this->BaseT().VisitDefault(iter); }
   bool ViBoolean(Cursor iter) { return this->BaseT().VisitDefault(iter); }
diff --git a/ccl/rslang/include/ccl/rslang/TypeAuditor.h b/ccl/rslang/include/ccl/rslang/TypeAuditor.h
index f529ee6..5db661f 100644
--- a/ccl/rslang/include/ccl/rslang/TypeAuditor.h
+++ b/ccl/rslang/include/ccl/rslang/TypeAuditor.h
@@ -104,11 +104,10 @@ protected:
   bool ViBoolean(Cursor iter);
 
   bool ViDeclarative(Cursor iter);
-  bool ViImperative(Cursor iter);
-  bool ViImpDeclare(Cursor iter);
-  bool ViImpAssign(Cursor iter);
-  bool ViImpCheck(Cursor iter) { return VisitAllAndSetCurrent(iter, LogicT{}); }
   bool ViRecursion(Cursor iter);
+  bool ViImperative(Cursor iter);
+  bool ViIterate(Cursor iter);
+  bool ViAssign(Cursor iter);
 
   bool ViTuple(Cursor iter);
   bool ViEnumeration(Cursor iter);
diff --git a/ccl/rslang/include/ccl/rslang/ValueAuditor.h b/ccl/rslang/include/ccl/rslang/ValueAuditor.h
index 76d7312..33a3ea8 100644
--- a/ccl/rslang/include/ccl/rslang/ValueAuditor.h
+++ b/ccl/rslang/include/ccl/rslang/ValueAuditor.h
@@ -65,10 +65,9 @@ protected:
 
   bool ViDeclarative(Cursor iter);
   bool ViImperative(Cursor iter);
-  bool ViImpDeclare(Cursor iter) { return AssertChildIsValue(iter, 1); }
-  bool ViImpAssign(Cursor iter) { return AssertChildIsValue(iter, 1); }
-  bool ViImpCheck(Cursor iter) { return VisitAllAndSetCurrent(iter, ValueClass::value); }
   bool ViRecursion(Cursor iter) { return AssertAllValues(iter); }
+  bool ViIterate(Cursor iter) { return AssertChildIsValue(iter, 1); }
+  bool ViAssign(Cursor iter) { return AssertChildIsValue(iter, 1); }
 
   bool ViTuple(Cursor iter) { return AssertAllValues(iter); }
   bool ViEnumeration(Cursor iter) { return AssertAllValues(iter); }
diff --git a/ccl/rslang/src/ASTInterpreter.cpp b/ccl/rslang/src/ASTInterpreter.cpp
index 023ffa7..d85264d 100644
--- a/ccl/rslang/src/ASTInterpreter.cpp
+++ b/ccl/rslang/src/ASTInterpreter.cpp
@@ -25,7 +25,7 @@ public:
   
 private:
   struct BlockMeta {
-    TokenID type{ TokenID::NT_IMP_LOGIC };
+    TokenID rootID{};
     uint32_t arg{};
     std::optional<object::StructuredData> domain{};
   };
@@ -44,21 +44,22 @@ public:
     CreateBlockMetadata();
     for (current = 0; ; ++current) {
       incrementIter = false;
-      if (IsDone()) {
+      if (HasReachedEnd()) {
         if (!SaveElement()) {
           return false;
         }
-      } else {
-        if (!ProcessBlock()) {
-          return false;
-        }
+      } else if (!ProcessBlock()) {
+        return false;
       }
       if (incrementIter && !PrepareNextIteration()) {
         return true;
       }
       if (++parent.iterationCounter > MAX_ITERATIONS) {
-        parent.OnError(ValueEID::iterationsLimit, imperative->pos.start,
-                       std::to_string(MAX_ITERATIONS));
+        parent.OnError(
+          ValueEID::iterationsLimit,
+          imperative->pos.start,
+          std::to_string(MAX_ITERATIONS)
+        );
         return false;
       }
     }
@@ -70,24 +71,23 @@ private:
     iter.MoveToChild(1);
     do {
       BlockMeta newBlock{};
-      newBlock.type = iter->id;
-      switch (newBlock.type) {
-      case TokenID::NT_IMP_DECLARE: {
+      newBlock.rootID = iter->id;
+      switch (newBlock.rootID) {
+      case TokenID::ITERATE: {
         newBlock.arg = *begin(parent.nodeVars[iter.Child(0).get()]);
         break;
       }
-      case TokenID::NT_IMP_ASSIGN: {
+      case TokenID::ASSIGN: {
         newBlock.arg = *begin(parent.nodeVars[iter.Child(0).get()]);
         break;
       }
-      default:
-      case TokenID::NT_IMP_LOGIC: break;
+      default: break;
       }
       metaData.emplace_back(std::move(newBlock));
     } while (iter.MoveToNextSibling());
   }
 
-  [[nodiscard]] bool IsDone() const noexcept {
+  [[nodiscard]] bool HasReachedEnd() const noexcept {
     return current + 1 >= imperative.ChildrenCount();
   }
 
@@ -107,42 +107,38 @@ private:
     child.MoveToChild(static_cast<Index>(current + 1));
     auto& meta = metaData.at(static_cast<size_t>(current));
 
-    switch (meta.type) {
-    default:
-    case TokenID::NT_IMP_LOGIC: {
-      const auto predicatValue = parent.EvaluateChild(child, 0);
-      if (!predicatValue.has_value()) {
+    switch (meta.rootID) {
+    default: {
+      const auto predicatValue = parent.EvaluateChild(imperative, static_cast<Index>(current + 1));
+      if (!predicatValue.has_value() || !std::holds_alternative<bool>(predicatValue.value())) {
         return false;
-      } else {
-        incrementIter = !std::get<bool>(predicatValue.value());
-        return true;
       }
+      incrementIter = !std::get<bool>(predicatValue.value());
+      return true;
     }
-    case TokenID::NT_IMP_DECLARE: {
+    case TokenID::ITERATE: {
       const auto domain = parent.ExtractDomain(child);
       if (!domain.has_value()) {
         return false;
-      } else if (domain->B().IsEmpty()) {
+      } 
+      if (domain->B().IsEmpty()) {
         incrementIter = true;
-        return true;
       } else {
         meta.domain = domain.value();
-
         auto element = std::begin(meta.domain->B());
         parent.idsData[meta.arg] = *element;
         blockStack.emplace(current);
         iterStack.emplace(element);
-        return true;
       }
+      return true;
     }
-    case TokenID::NT_IMP_ASSIGN: {
+    case TokenID::ASSIGN: {
       const auto localValue = parent.ExtractDomain(child);
       if (!localValue.has_value()) {
         return false;
-      } else {
-        parent.idsData[meta.arg] = localValue.value();
-        return true;
       }
+      parent.idsData[meta.arg] = localValue.value();
+      return true;
     }
     }
   }
@@ -275,7 +271,11 @@ bool ASTInterpreter::ViCard(Cursor iter) {
   }
   const auto size = std::get<StructuredData>(base.value()).B().Cardinality();
   if (size == StructuredData::SET_INFINITY) {
-    OnError(ValueEID::typedOverflow, iter->pos.start, std::to_string(StructuredData::SET_INFINITY));
+    OnError(
+      ValueEID::typedOverflow,
+      iter->pos.start,
+      std::to_string(StructuredData::SET_INFINITY)
+    );
     return false;
   }
   return SetCurrent(Factory::Val(size));
@@ -291,13 +291,19 @@ bool ASTInterpreter::ViQuantifier(Cursor iter) {
   const auto isUniversal = iter->id == TokenID::FORALL;
   for (const auto& child : domain->B()) {
     if (++iterationCounter > MAX_ITERATIONS) {
-      OnError(ValueEID::iterationsLimit, iter->pos.start, std::to_string(MAX_ITERATIONS));
+      OnError(
+        ValueEID::iterationsLimit,
+        iter->pos.start,
+        std::to_string(MAX_ITERATIONS)
+      );
       return false;
     }
     idsData[varID] = child;
-    if (const auto iterationValue = EvaluateChild(iter, 2); !iterationValue.has_value()) {
+    const auto iterationValue = EvaluateChild(iter, 2);
+    if (!iterationValue.has_value()) {
       return false;
-    } else if (std::get<bool>(iterationValue.value()) != isUniversal) {
+    }
+    if (std::get<bool>(iterationValue.value()) != isUniversal) {
       return SetCurrent(!isUniversal);
     }
   }
@@ -345,8 +351,7 @@ bool ASTInterpreter::ViLogicBinary(Cursor iter) {
 }
 
 bool ASTInterpreter::TryEvaluateFromFirstArg(TokenID operation, bool firstArgValue) noexcept {
-  if ((operation == TokenID::AND && !firstArgValue) ||
-    (operation == TokenID::OR && firstArgValue)) {
+  if ((operation == TokenID::AND && !firstArgValue) || (operation == TokenID::OR && firstArgValue)) {
     return SetCurrent(firstArgValue);
   } else if (operation == TokenID::IMPLICATION && !firstArgValue) {
     return SetCurrent(!firstArgValue);
@@ -396,7 +401,11 @@ bool ASTInterpreter::ViDeclarative(Cursor iter) {
   auto result = Factory::EmptySet();
   for (const auto& child : setDomain->B()) {
     if (++iterationCounter > MAX_ITERATIONS) {
-      OnError(ValueEID::iterationsLimit, iter->pos.start, std::to_string(MAX_ITERATIONS));
+      OnError(
+        ValueEID::iterationsLimit,
+        iter->pos.start,
+        std::to_string(MAX_ITERATIONS)
+      );
       return false;
     }
     idsData[varID] = child;
@@ -428,7 +437,11 @@ bool ASTInterpreter::ViRecursion(Cursor iter) {
   StructuredData current = initial.value();
   do {
     if (++iterationCounter > MAX_ITERATIONS) {
-      OnError(ValueEID::iterationsLimit, iter->pos.start, std::to_string(MAX_ITERATIONS));
+      OnError(
+        ValueEID::iterationsLimit,
+        iter->pos.start,
+        std::to_string(MAX_ITERATIONS)
+      );
       return false;
     }
 
@@ -454,16 +467,21 @@ bool ASTInterpreter::ViRecursion(Cursor iter) {
 bool ASTInterpreter::ViDecart(Cursor iter) {
   std::vector<StructuredData> args{};
   for (Index child = 0; child < iter.ChildrenCount(); ++child) {
-    if (const auto childValue = EvaluateChild(iter, child); !childValue.has_value()) {
+    const auto childValue = EvaluateChild(iter, child);
+    if (!childValue.has_value()) {
       return false;
-    } else {
-      args.emplace_back(std::get<StructuredData>(childValue.value()));
-    }
+    } 
+     args.emplace_back(std::get<StructuredData>(childValue.value()));
   }
 
   curValue = Factory::Decartian(args);
-  if (std::get<StructuredData>(curValue).B().Cardinality() == StructuredData::SET_INFINITY) {
-    OnError(ValueEID::typedOverflow, iter->pos.start, std::to_string(StructuredData::SET_INFINITY));
+  const auto cardinality = std::get<StructuredData>(curValue).B().Cardinality();
+  if (cardinality == StructuredData::SET_INFINITY) {
+    OnError(
+      ValueEID::typedOverflow,
+      iter->pos.start,
+      std::to_string(StructuredData::SET_INFINITY)
+    );
     return false;
   }
   return true;
@@ -627,7 +645,10 @@ bool ASTInterpreter::ViDebool(Cursor iter) {
   }
   const auto value = std::get<StructuredData>(childValue.value());
   if (value.B().Cardinality() != 1) {
-    OnError(ValueEID::invalidDebool, iter->pos.start);
+    OnError(
+      ValueEID::invalidDebool,
+      iter->pos.start
+    );
     return false;
   }
   return SetCurrent(std::get<StructuredData>(childValue.value()).B().Debool());
diff --git a/ccl/rslang/src/ASTNormalizer.cpp b/ccl/rslang/src/ASTNormalizer.cpp
index 333e543..b8deb56 100644
--- a/ccl/rslang/src/ASTNormalizer.cpp
+++ b/ccl/rslang/src/ASTNormalizer.cpp
@@ -15,11 +15,16 @@ void Normalizer::Normalize(SyntaxTree::Node& root) {
     break;
   }
   case TokenID::NT_RECURSIVE_FULL:
-  case TokenID::NT_RECURSIVE_SHORT:
+  case TokenID::NT_RECURSIVE_SHORT: {
+    Recursion(root);
+    break;
+  }
   case TokenID::NT_DECLARATIVE_EXPR: {
-    if (root(0).token.id == TokenID::NT_TUPLE_DECL) {
-      TupleDeclaration(root);
-    }
+    Declarative(root);
+    break;
+  }
+  case TokenID::NT_IMPERATIVE_EXPR: {
+    Imperative(root);
     break;
   }
   case TokenID::NT_FUNC_CALL: {
@@ -42,6 +47,46 @@ void Normalizer::Quantifier(SyntaxTree::Node& quant) {
   }
 }
 
+void Normalizer::Declarative(SyntaxTree::Node& root) {
+  if (root(0).token.id != TokenID::NT_TUPLE_DECL) {
+    return;
+  }
+  const auto newName = ProcessTupleDeclaration(root(0));
+  SubstituteTupleVariables(root(1), newName);
+  SubstituteTupleVariables(root(2), newName);
+}
+
+void Normalizer::Recursion(SyntaxTree::Node& root) {
+  if (root(0).token.id != TokenID::NT_TUPLE_DECL) {
+    return;
+  }
+  const auto newName = ProcessTupleDeclaration(root(0));
+  SubstituteTupleVariables(root(2), newName);
+  if (root.token.id == TokenID::NT_RECURSIVE_FULL) {
+    SubstituteTupleVariables(root(3), newName);
+  }
+}
+
+void Normalizer::Imperative(SyntaxTree::Node& root) {
+  for (Index child = 1; child < root.ChildrenCount(); ++child) {
+    const auto childID = root(child).token.id;
+    if (childID != TokenID::ITERATE && childID != TokenID::ASSIGN) {
+      continue;
+    }
+    auto& declRoot = root(child);
+    if (declRoot(0).token.id != TokenID::NT_TUPLE_DECL) {
+      continue;
+    }
+    const auto newName = ProcessTupleDeclaration(declRoot(0));
+    for (Index child2 = 0; child2 < root.ChildrenCount(); ++child2) {
+      if (child2 != child) {
+        SubstituteTupleVariables(root(child2), newName);
+      }
+    }
+    SubstituteTupleVariables(root, newName);
+  }
+}
+
 void Normalizer::EnumDeclaration(SyntaxTree::Node& quant) {
   auto newQuant = std::make_unique<SyntaxTree::Node>(quant.token);
   newQuant->AddChildCopy(quant(0));
@@ -61,32 +106,12 @@ void Normalizer::TupleDeclaration(
   SyntaxTree::Node& declaration,
   SyntaxTree::Node& predicate
 ) {
-  const auto newName = CreateTupleName(declaration);
-  declaration.RemoveAll();
-  declaration.token.data = TokenData{ newName };
-  declaration.token.id = TokenID::ID_LOCAL;
+  const auto newName = ProcessTupleDeclaration(declaration);
   SubstituteTupleVariables(predicate, newName);
 }
 
-void Normalizer::TupleDeclaration(SyntaxTree::Node& target) {
-  const auto token = target.token.id;
-  auto newName = CreateTupleName(target(0));
-
-  target(0).RemoveAll();
-  target(0).token.id = TokenID::ID_LOCAL;
-  target(0).token.data = TokenData{ newName };
-
-  if (token == TokenID::NT_DECLARATIVE_EXPR) {
-    SubstituteTupleVariables(target(1), newName);
-  }
-  SubstituteTupleVariables(target(2), newName);
-  if (token == TokenID::NT_RECURSIVE_FULL) {
-    SubstituteTupleVariables(target(3), newName);
-  }
-}
-
-std::string Normalizer::CreateTupleName(const SyntaxTree::Node& root) {
-  tuples.clear();
+std::string Normalizer::ProcessTupleDeclaration(SyntaxTree::Node& root) {
+  tupleSubstitutes.clear();
   std::string newName{ '@' };
 
   std::stack<const SyntaxTree::Node*> nodeStack{};
@@ -101,7 +126,7 @@ std::string Normalizer::CreateTupleName(const SyntaxTree::Node& root) {
     if (curNode->token.id == TokenID::ID_LOCAL) {
       const auto& name = curNode->token.data.ToText();
       newName += name;
-      tuples.insert({ name, curPath });
+      tupleSubstitutes.insert({ name, curPath });
     } else if (const auto childCount = curNode->ChildrenCount(); childCount > 0) {
       for (auto child = static_cast<Index>(childCount - 1); child >= 0; --child) {
         curPath.emplace_back(static_cast<Index>(child + 1));
@@ -111,15 +136,20 @@ std::string Normalizer::CreateTupleName(const SyntaxTree::Node& root) {
       }
     }
   }
+  root.RemoveAll();
+  root.token.data = TokenData{ newName };
+  root.token.id = TokenID::ID_LOCAL;
   return newName;
 }
 
 void Normalizer::SubstituteTupleVariables(SyntaxTree::Node& target, const std::string& newName) {
   for (Index child = 0; child < target.ChildrenCount(); ++child) {
-    if (target(child).token.id == TokenID::ID_LOCAL) {
+    if (target(child).token.id != TokenID::ID_LOCAL) {
+      SubstituteTupleVariables(target(child), newName);
+    } else {
       const auto& localName = target(child).token.data.ToText();
-      if (tuples.contains(localName)) {
-        const auto& indexes = tuples.at(localName);
+      if (tupleSubstitutes.contains(localName)) {
+        const auto& indexes = tupleSubstitutes.at(localName);
         target(child).token.data = TokenData{ newName };
         for (const auto prIndex : indexes) {
           target.ExtendChild(child, TokenID::SMALLPR);
@@ -127,21 +157,19 @@ void Normalizer::SubstituteTupleVariables(SyntaxTree::Node& target, const std::s
           target(child).token.data = TokenData{ std::vector<Index>{ prIndex } };
         }
       }
-    } else {
-      SubstituteTupleVariables(target(child), newName);
     }
   }
 }
 
 void Normalizer::Function(SyntaxTree::Node& func) {
-  nodes.clear();
+  nodeSubstitutes.clear();
   nameSubstitutes.clear();
   
   const auto* funcTree = termFuncs(func(0).token.data.ToText());
   if (funcTree != nullptr) {
     const auto argNames = ArgNames(funcTree->root->At(1).At(0));
     for (Index child = 1; child < func.ChildrenCount(); ++child) {
-      nodes.insert({ argNames.at(static_cast<size_t>(child) - 1), &func(child) });
+      nodeSubstitutes.insert({ argNames.at(static_cast<size_t>(child) - 1), &func(child) });
     }
     SyntaxTree newTree = *funcTree;
     SubstituteArgs(newTree.root->At(1).At(1), func.token.pos);
@@ -167,8 +195,8 @@ void Normalizer::SubstituteArgs(SyntaxTree::Node& target, const StrRange pos) {
     }
   } else {
     const auto& localName = target.token.ToString();
-    if (nodes.contains(localName)) {
-      target = *nodes.at(localName);
+    if (nodeSubstitutes.contains(localName)) {
+      target = *nodeSubstitutes.at(localName);
     } else {
       const auto& oldName = target.token.ToString();
       std::string newName{};
diff --git a/ccl/rslang/src/AsciiLexerImpl.l b/ccl/rslang/src/AsciiLexerImpl.l
index d5b7637..c1dcfc5 100644
--- a/ccl/rslang/src/AsciiLexerImpl.l
+++ b/ccl/rslang/src/AsciiLexerImpl.l
@@ -100,8 +100,8 @@ R{number}           { return TokenID::ID_RADICAL; }
 {global_id}         { return TokenID::ID_GLOBAL; }
 {local_id}          { return TokenID::ID_LOCAL; }
 
-"\assign"           { return TokenID::PUNC_ASSIGN; }
-"\from"             { return TokenID::PUNC_ITERATE; }
+"\assign"           { return TokenID::ASSIGN; }
+"\from"             { return TokenID::ITERATE; }
 "\defexpr"          { return TokenID::PUNC_DEFINE; }
 "\deftype"          { return TokenID::PUNC_STRUCT; }
 "("                 { return TokenID::PUNC_PL; }
diff --git a/ccl/rslang/src/GeneratorImplAST.cpp b/ccl/rslang/src/GeneratorImplAST.cpp
index 6ae9403..5c4e575 100644
--- a/ccl/rslang/src/GeneratorImplAST.cpp
+++ b/ccl/rslang/src/GeneratorImplAST.cpp
@@ -147,13 +147,6 @@ bool GeneratorImplAST::ViLogicBinary(Cursor iter) {
   return true;
 }
 
-bool GeneratorImplAST::ViEquals(Cursor iter) {
-  OutputChild(iter, 0);
-  rsText += iter->ToString(syntax);
-  OutputChild(iter, 1);
-  return true;
-}
-
 bool GeneratorImplAST::ViDeclarative(Cursor iter) {
   rsText += Token::Str(TokenID::DECLARATIVE, syntax);
   rsText += '{';
@@ -181,30 +174,11 @@ bool GeneratorImplAST::ViImperative(Cursor iter) {
   return true;
 }
 
-bool GeneratorImplAST::ViImpDeclare(Cursor iter) {
-  OutputChild(iter, 0);
-  rsText += Token::Str(TokenID::PUNC_ITERATE, syntax);
-  OutputChild(iter, 1);
-  return true;
-}
-
-bool GeneratorImplAST::ViImpAssign(Cursor iter) {
-  OutputChild(iter, 0);
-  rsText += Token::Str(TokenID::PUNC_ASSIGN, syntax);
-  OutputChild(iter, 1);
-  return true;
-}
-
-bool GeneratorImplAST::ViImpCheck(Cursor iter) {
-  OutputChild(iter, 0);
-  return true;
-}
-
 bool GeneratorImplAST::ViRecursion(Cursor iter) {
   rsText += Token::Str(TokenID::RECURSIVE, syntax);
   rsText += '{';
   OutputChild(iter, 0);
-  rsText += Token::Str(TokenID::PUNC_ASSIGN);
+  rsText += Token::Str(TokenID::ASSIGN);
   OutputChild(iter, 1);
   rsText += R"( | )";
   OutputChild(iter, 2);
@@ -252,19 +226,28 @@ void GeneratorImplAST::OutputChild(const Cursor& iter, const Index index, const
   }
 }
 
-void GeneratorImplAST::EnumChildren(const Cursor& iter, const std::string& separator) {
+bool GeneratorImplAST::OutputBinary(const Cursor& iter) {
+  OutputChild(iter, 0);
+  rsText += iter->ToString(syntax);
+  OutputChild(iter, 1);
+  return true;
+}
+
+bool GeneratorImplAST::EnumChildren(const Cursor& iter, const std::string& separator) {
   for (Index child = 0; child < iter.ChildrenCount(); ++child) {
     if (child > 0) {
       rsText += separator;
     }
     OutputChild(iter, child);
   }
+  return true;
 }
 
-void GeneratorImplAST::EnumChildren(const Cursor& iter, const char left, const char right, const std::string& separator) {
+bool GeneratorImplAST::EnumChildren(const Cursor& iter, const char left, const char right, const std::string& separator) {
   rsText += left;
   EnumChildren(iter, separator);
   rsText += right;
+  return true;
 }
 
 } // namespace ccl::rslang
\ No newline at end of file
diff --git a/ccl/rslang/src/MathLexerImpl.l b/ccl/rslang/src/MathLexerImpl.l
index 9d23383..55b0e89 100644
--- a/ccl/rslang/src/MathLexerImpl.l
+++ b/ccl/rslang/src/MathLexerImpl.l
@@ -67,7 +67,7 @@ local_id    (_|{lower}){alnum}*
 \x{21D2}            { return TokenID::IMPLICATION; }
 \x{21D4}            { return TokenID::EQUIVALENT; }
 
-:\x{2208}           { return TokenID::PUNC_ITERATE; }
+:\x{2208}           { return TokenID::ITERATE; }
 \x{2208}            { return TokenID::IN; }
 \x{2209}            { return TokenID::NOTIN; }
 \x{2286}            { return TokenID::SUBSET_OR_EQ; }
@@ -104,7 +104,7 @@ R{number}           { return TokenID::ID_RADICAL; }
 {global_id}         { return TokenID::ID_GLOBAL; }
 {local_id}          { return TokenID::ID_LOCAL; }
 
-":="                { return TokenID::PUNC_ASSIGN; }
+":="                { return TokenID::ASSIGN; }
 ":=="               { return TokenID::PUNC_DEFINE; }
 "::="               { return TokenID::PUNC_STRUCT; }
 "("                 { return TokenID::PUNC_PL; }
diff --git a/ccl/rslang/src/NameCollector.cpp b/ccl/rslang/src/NameCollector.cpp
index 68aacf9..fa62f84 100644
--- a/ccl/rslang/src/NameCollector.cpp
+++ b/ccl/rslang/src/NameCollector.cpp
@@ -29,14 +29,14 @@ bool ASTInterpreter::NameCollector::ViGlobalDeclaration(Cursor iter) {
     return false; // TODO: specify error
   }
   switch (iter(0).id) {
-  default:
-  case TokenID::ID_FUNCTION:
-  case TokenID::ID_PREDICATE: {
-    return false; // TODO: specify error
-  }
-  case TokenID::ID_GLOBAL: {
-    return iter.ChildrenCount() == 2 && VisitChild(iter, 1);
-  }
+    default:
+    case TokenID::ID_FUNCTION:
+    case TokenID::ID_PREDICATE: {
+      return false; // TODO: specify error
+    }
+    case TokenID::ID_GLOBAL: {
+      return iter.ChildrenCount() == 2 && VisitChild(iter, 1);
+    }
   }
 }
 
@@ -93,14 +93,13 @@ bool ASTInterpreter::NameCollector::ViImperative(Cursor iter) {
   child.MoveToChild(1);
   do {
     switch (child->id) {
-    case TokenID::NT_IMP_ASSIGN:
-    case TokenID::NT_IMP_DECLARE: {
-      const auto varID = *begin(parent.nodeVars[iter.Child(0).get()]);
-      vars.erase(std::remove(begin(vars), end(vars), varID), end(vars));
-      break;
-    }
-    default:
-    case TokenID::NT_IMP_LOGIC: break;
+      case TokenID::ITERATE:
+      case TokenID::ASSIGN: {
+        const auto varID = *begin(parent.nodeVars[iter.Child(0).get()]);
+        vars.erase(std::remove(begin(vars), end(vars), varID), end(vars));
+        break;
+      }
+      default: break;
     }
   } while (child.MoveToNextSibling());
   return true;
diff --git a/ccl/rslang/src/RSParser.cpp b/ccl/rslang/src/RSParser.cpp
index 9da87c0..08bf301 100644
--- a/ccl/rslang/src/RSParser.cpp
+++ b/ccl/rslang/src/RSParser.cpp
@@ -18,6 +18,7 @@
 #endif
 
 #include <optional>
+#include <unordered_map>
 
 namespace ccl::rslang::detail {
 
@@ -186,6 +187,26 @@ RawNode TermDeclaration(
   return result;
 }
 
+RawNode TupleDeclaration(ParserState* state, RawNode tuple) {
+  // TODO: check tuple contains only local variables, ParseEID::expectedLocal
+  std::vector<Node*> stack{ tuple.get()};
+  while (!stack.empty()) {
+    auto node = stack.back();
+    const auto id = node->token.id;
+    stack.pop_back();
+    if (id == TokenID::NT_TUPLE) {
+      node->token.id = TokenID::NT_TUPLE_DECL;
+    } else if (id != TokenID::ID_LOCAL) {
+      state->OnError(ParseEID::expectedLocal, node->token.pos.start);
+      return nullptr;
+    }
+    for (const auto& child: node->children) {
+      stack.emplace_back(child.get());
+    }
+  }
+  return tuple;
+}
+
 RawNode FullRecursion(
   RawNode rec,
   RawNode declaration, 
@@ -232,6 +253,30 @@ RawNode Imperative(RawNode imp, RawNode value, RawNode actions, RawNode rc) {
   return result;
 }
 
+bool SemanticCheck(ParserState* state, RawNode root) {
+  std::vector<Node*> stack{ root.get() };
+  std::vector<Node*> parents{ nullptr };
+  while (!stack.empty()) {
+    const auto node = stack.back();
+    stack.pop_back();
+    const auto parent = parents.back();
+    parents.pop_back();
+
+    const auto id = node->token.id;
+    if (id == TokenID::ASSIGN || id == TokenID::ITERATE) {
+      if (parent == nullptr || parent->token.id != TokenID::NT_IMPERATIVE_EXPR) {
+        state->OnError(ParseEID::invalidImperative, node->token.pos.start);
+        return false;
+      }
+    }
+    for (const auto& child: node->children) {
+      stack.emplace_back(child.get());
+      parents.emplace_back(node);
+    }
+  }
+  return true;
+}
+
 SyntaxTree::RawNode CreateNodeRecursive(Node& astNode) {
   if (astNode.token.id == TokenID::PUNC_PL) {
     return CreateNodeRecursive(*astNode.children.at(0));
@@ -244,25 +289,29 @@ SyntaxTree::RawNode CreateNodeRecursive(Node& astNode) {
   }
 }
 
-void ParserState::CreateSyntaxTree(RawNode root) {
+bool ParserState::CreateSyntaxTree(RawNode root) {
+  if (!SemanticCheck(this, root)) {
+    return false;
+  }
   parsedTree = std::make_unique<SyntaxTree>(CreateNodeRecursive(*root));
+  return true;
 }
 
-void ParserState::FinalizeExpression(RawNode expr) {
-  CreateSyntaxTree(expr);
+bool ParserState::FinalizeExpression(RawNode expr) {
+  return CreateSyntaxTree(expr);
 }
 
-void ParserState::FinalizeCstEmpty(RawNode cst, RawNode mode) {
+bool ParserState::FinalizeCstEmpty(RawNode cst, RawNode mode) {
   mode->token.pos = StrRange{ cst->token.pos.start, mode->token.pos.finish };
   mode->children.emplace_back(cst);
-  CreateSyntaxTree(mode);
+  return CreateSyntaxTree(mode);
 }
 
-void ParserState::FinalizeCstExpression(RawNode cst, RawNode mode, RawNode data) {
+bool ParserState::FinalizeCstExpression(RawNode cst, RawNode mode, RawNode data) {
   mode->token.pos = StrRange{ cst->token.pos.start, data->token.pos.finish };
   mode->children.emplace_back(cst);
   mode->children.emplace_back(data);
-  CreateSyntaxTree(mode);
+  return CreateSyntaxTree(mode);
 }
 
 } // namespace ccl::rslang::detail
diff --git a/ccl/rslang/src/RSParserImpl.cpp b/ccl/rslang/src/RSParserImpl.cpp
index 546a33b..67290dd 100644
--- a/ccl/rslang/src/RSParserImpl.cpp
+++ b/ccl/rslang/src/RSParserImpl.cpp
@@ -585,373 +585,349 @@ namespace ccl { namespace rslang { namespace detail {
           switch (yyn)
             {
   case 3: // expression: logic_or_setexpr
-#line 263 "RSParserImpl.y"
-                                            { state->FinalizeExpression(yystack_[0].value); }
+#line 271 "RSParserImpl.y"
+                                            { if(!state->FinalizeExpression(yystack_[0].value)) YYABORT; }
 #line 591 "RSParserImpl.cpp"
     break;
 
   case 4: // expression: function_definition
-#line 264 "RSParserImpl.y"
-                                            { state->FinalizeExpression(yystack_[0].value); }
+#line 272 "RSParserImpl.y"
+                                            { if(!state->FinalizeExpression(yystack_[0].value)) YYABORT; }
 #line 597 "RSParserImpl.cpp"
     break;
 
   case 5: // global_declaration: GLOBAL DEFINE
-#line 268 "RSParserImpl.y"
-                                            { state->FinalizeCstEmpty(yystack_[1].value, yystack_[0].value); }
+#line 276 "RSParserImpl.y"
+                                            { if(!state->FinalizeCstEmpty(yystack_[1].value, yystack_[0].value)) YYABORT; }
 #line 603 "RSParserImpl.cpp"
     break;
 
   case 6: // global_declaration: GLOBAL STRUCT setexpr
-#line 269 "RSParserImpl.y"
-                                            { state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+#line 277 "RSParserImpl.y"
+                                            { if(!state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value)) YYABORT; }
 #line 609 "RSParserImpl.cpp"
     break;
 
   case 7: // global_declaration: GLOBAL DEFINE logic_or_setexpr
-#line 270 "RSParserImpl.y"
-                                            { state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+#line 278 "RSParserImpl.y"
+                                            { if(!state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value)) YYABORT; }
 #line 615 "RSParserImpl.cpp"
     break;
 
   case 8: // global_declaration: FUNCTION DEFINE function_definition
-#line 271 "RSParserImpl.y"
-                                            { state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+#line 279 "RSParserImpl.y"
+                                            { if(!state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value)) YYABORT; }
 #line 621 "RSParserImpl.cpp"
     break;
 
   case 9: // global_declaration: PREDICATE DEFINE function_definition
-#line 272 "RSParserImpl.y"
-                                                { state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+#line 280 "RSParserImpl.y"
+                                                { if(!state->FinalizeCstExpression(yystack_[2].value, yystack_[1].value, yystack_[0].value)) YYABORT; }
 #line 627 "RSParserImpl.cpp"
     break;
 
   case 12: // function_definition: LS arguments RS logic_or_setexpr
-#line 281 "RSParserImpl.y"
+#line 289 "RSParserImpl.y"
                                             { yylhs.value = FunctionDeclaration(yystack_[3].value, yystack_[2].value, yystack_[0].value); }
 #line 633 "RSParserImpl.cpp"
     break;
 
   case 13: // function_definition: LS error
-#line 282 "RSParserImpl.y"
+#line 290 "RSParserImpl.y"
                                             { state->OnError(ParseEID::expectedDeclaration); YYABORT; }
 #line 639 "RSParserImpl.cpp"
     break;
 
   case 14: // arguments: declaration
-#line 287 "RSParserImpl.y"
+#line 295 "RSParserImpl.y"
                                             { yylhs.value = AddNode(TokenID::NT_ARGUMENTS, yystack_[0].value); }
 #line 645 "RSParserImpl.cpp"
     break;
 
   case 15: // arguments: arguments COMMA declaration
-#line 288 "RSParserImpl.y"
+#line 296 "RSParserImpl.y"
                                             { yylhs.value = Enumeration(TokenID::NT_ARGUMENTS, yystack_[2].value, yystack_[0].value); }
 #line 651 "RSParserImpl.cpp"
     break;
 
   case 16: // arguments: arguments COMMA error
-#line 289 "RSParserImpl.y"
+#line 297 "RSParserImpl.y"
                                             { state->OnError(ParseEID::expectedLocal); YYABORT; }
 #line 657 "RSParserImpl.cpp"
     break;
 
   case 17: // declaration: LOCAL IN setexpr
-#line 292 "RSParserImpl.y"
+#line 300 "RSParserImpl.y"
                                             { yylhs.value = AddNode(TokenID::NT_ARG_DECL, yystack_[2].value, yystack_[0].value); }
 #line 663 "RSParserImpl.cpp"
     break;
 
   case 18: // declaration: LOCAL error
-#line 293 "RSParserImpl.y"
+#line 301 "RSParserImpl.y"
                                             { state->OnError(ParseEID::expectedDeclaration); YYABORT; }
 #line 669 "RSParserImpl.cpp"
     break;
 
-  case 20: // variable: LP var_enum RPE
-#line 298 "RSParserImpl.y"
-                                            { yylhs.value = ReplaceBrackets(TokenID::NT_TUPLE_DECL, yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 20: // variable: tuple
+#line 306 "RSParserImpl.y"
+                                            { yylhs.value = TupleDeclaration(state, yystack_[0].value); if (!yylhs.value) YYABORT; }
 #line 675 "RSParserImpl.cpp"
     break;
 
-  case 21: // var_enum: var_all COMMA var_all
-#line 301 "RSParserImpl.y"
-                                            { yylhs.value = Enumeration(TokenID::INTERRUPT, yystack_[2].value, yystack_[0].value); }
+  case 22: // variable_pack: variable_pack COMMA variable_pack
+#line 310 "RSParserImpl.y"
+                                            { yylhs.value = Enumeration(TokenID::NT_ENUM_DECL, yystack_[2].value, yystack_[0].value); }
 #line 681 "RSParserImpl.cpp"
     break;
 
-  case 22: // var_enum: var_all COMMA error
-#line 302 "RSParserImpl.y"
+  case 23: // variable_pack: variable_pack COMMA error
+#line 311 "RSParserImpl.y"
                                             { state->OnError(ParseEID::expectedLocal); YYABORT; }
 #line 687 "RSParserImpl.cpp"
     break;
 
-  case 30: // logic_par: LP logic_binary RPE
-#line 320 "RSParserImpl.y"
+  case 32: // logic_par: LP logic_binary RPE
+#line 330 "RSParserImpl.y"
                                             { yylhs.value = RemoveBrackets(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 693 "RSParserImpl.cpp"
     break;
 
-  case 31: // logic_par: LP logic_predicates RPE
-#line 321 "RSParserImpl.y"
+  case 33: // logic_par: LP logic_predicates RPE
+#line 331 "RSParserImpl.y"
                                             { yylhs.value = RemoveBrackets(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 699 "RSParserImpl.cpp"
     break;
 
-  case 32: // logic_predicates: setexpr binary_predicate setexpr
-#line 325 "RSParserImpl.y"
+  case 34: // logic_predicates: setexpr binary_predicate setexpr
+#line 335 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 705 "RSParserImpl.cpp"
     break;
 
-  case 44: // logic_unary: NOT logic_no_binary
-#line 342 "RSParserImpl.y"
-                                            { yylhs.value = UnaryOperation(yystack_[1].value, yystack_[0].value);}
+  case 35: // logic_predicates: variable ITERATE setexpr
+#line 336 "RSParserImpl.y"
+                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 711 "RSParserImpl.cpp"
     break;
 
-  case 45: // logic_unary: quantifier quant_var IN setexpr logic_no_binary
-#line 343 "RSParserImpl.y"
-                                                      { yylhs.value = Quantifier(yystack_[4].value, yystack_[3].value, yystack_[1].value, yystack_[0].value);}
+  case 36: // logic_predicates: variable ASSIGN setexpr
+#line 337 "RSParserImpl.y"
+                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 717 "RSParserImpl.cpp"
     break;
 
-  case 46: // logic_unary: quantifier error
-#line 344 "RSParserImpl.y"
-                                            { state->OnError(ParseEID::invalidQuantifier); YYABORT; }
+  case 48: // logic_unary: NOT logic_no_binary
+#line 354 "RSParserImpl.y"
+                                            { yylhs.value = UnaryOperation(yystack_[1].value, yystack_[0].value);}
 #line 723 "RSParserImpl.cpp"
     break;
 
-  case 47: // logic_unary: PREDICATE LS setexpr_enum RS
-#line 345 "RSParserImpl.y"
-                                            { yylhs.value = FunctionCall(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 49: // logic_unary: quantifier variable_pack IN setexpr logic_no_binary
+#line 355 "RSParserImpl.y"
+                                                          { yylhs.value = Quantifier(yystack_[4].value, yystack_[3].value, yystack_[1].value, yystack_[0].value);}
 #line 729 "RSParserImpl.cpp"
     break;
 
-  case 55: // quant_var: LP error
-#line 359 "RSParserImpl.y"
+  case 50: // logic_unary: quantifier error
+#line 356 "RSParserImpl.y"
                                             { state->OnError(ParseEID::invalidQuantifier); YYABORT; }
 #line 735 "RSParserImpl.cpp"
     break;
 
-  case 56: // quant_var_enum: quant_var COMMA quant_var
-#line 362 "RSParserImpl.y"
-                                            { yylhs.value = Enumeration(TokenID::NT_ENUM_DECL, yystack_[2].value, yystack_[0].value); }
+  case 51: // logic_unary: PREDICATE LS setexpr_enum RS
+#line 357 "RSParserImpl.y"
+                                            { yylhs.value = FunctionCall(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 741 "RSParserImpl.cpp"
     break;
 
-  case 57: // quant_var_enum: quant_var COMMA error
-#line 363 "RSParserImpl.y"
-                                            { state->OnError(ParseEID::expectedLocal); YYABORT; }
+  case 54: // logic_binary: logic_all EQUIVALENT logic_all
+#line 365 "RSParserImpl.y"
+                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 747 "RSParserImpl.cpp"
     break;
 
-  case 58: // logic_binary: logic_all EQUIVALENT logic_all
-#line 367 "RSParserImpl.y"
+  case 55: // logic_binary: logic_all IMPLICATION logic_all
+#line 366 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 753 "RSParserImpl.cpp"
     break;
 
-  case 59: // logic_binary: logic_all IMPLICATION logic_all
-#line 368 "RSParserImpl.y"
+  case 56: // logic_binary: logic_all OR logic_all
+#line 367 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 759 "RSParserImpl.cpp"
     break;
 
-  case 60: // logic_binary: logic_all OR logic_all
-#line 369 "RSParserImpl.y"
+  case 57: // logic_binary: logic_all AND logic_all
+#line 368 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 765 "RSParserImpl.cpp"
     break;
 
-  case 61: // logic_binary: logic_all AND logic_all
-#line 370 "RSParserImpl.y"
-                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 62: // setexpr: FUNCTION LS setexpr_enum RS
+#line 378 "RSParserImpl.y"
+                                            { yylhs.value = FunctionCall(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 771 "RSParserImpl.cpp"
     break;
 
-  case 66: // setexpr: FUNCTION LS setexpr_enum RS
-#line 380 "RSParserImpl.y"
-                                            { yylhs.value = FunctionCall(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 63: // setexpr: text_function LP setexpr RPE
+#line 379 "RSParserImpl.y"
+                                            { yylhs.value = TextOperator(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 777 "RSParserImpl.cpp"
     break;
 
-  case 67: // setexpr: text_function LP setexpr RPE
-#line 381 "RSParserImpl.y"
-                                            { yylhs.value = TextOperator(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 70: // setexpr_enum: setexpr
+#line 390 "RSParserImpl.y"
+                                            { yylhs.value = AddNode(TokenID::INTERRUPT, yystack_[0].value); }
 #line 783 "RSParserImpl.cpp"
     break;
 
-  case 74: // setexpr_enum: setexpr
-#line 392 "RSParserImpl.y"
-                                            { yylhs.value = AddNode(TokenID::INTERRUPT, yystack_[0].value); }
+  case 72: // setexpr_enum_min2: setexpr_enum COMMA setexpr
+#line 394 "RSParserImpl.y"
+                                            { yylhs.value = Enumeration(TokenID::INTERRUPT, yystack_[2].value, yystack_[0].value); }
 #line 789 "RSParserImpl.cpp"
     break;
 
-  case 76: // setexpr_enum_min2: setexpr_enum COMMA setexpr
-#line 396 "RSParserImpl.y"
-                                            { yylhs.value = Enumeration(TokenID::INTERRUPT, yystack_[2].value, yystack_[0].value); }
+  case 81: // setexpr_binary: setexpr PLUS setexpr
+#line 412 "RSParserImpl.y"
+                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 795 "RSParserImpl.cpp"
     break;
 
-  case 85: // setexpr_binary: setexpr PLUS setexpr
-#line 414 "RSParserImpl.y"
+  case 82: // setexpr_binary: setexpr MINUS setexpr
+#line 413 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 801 "RSParserImpl.cpp"
     break;
 
-  case 86: // setexpr_binary: setexpr MINUS setexpr
-#line 415 "RSParserImpl.y"
+  case 83: // setexpr_binary: setexpr MULTIPLY setexpr
+#line 414 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 807 "RSParserImpl.cpp"
     break;
 
-  case 87: // setexpr_binary: setexpr MULTIPLY setexpr
-#line 416 "RSParserImpl.y"
+  case 84: // setexpr_binary: setexpr UNION setexpr
+#line 415 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 813 "RSParserImpl.cpp"
     break;
 
-  case 88: // setexpr_binary: setexpr UNION setexpr
-#line 417 "RSParserImpl.y"
+  case 85: // setexpr_binary: setexpr SET_MINUS setexpr
+#line 416 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 819 "RSParserImpl.cpp"
     break;
 
-  case 89: // setexpr_binary: setexpr SET_MINUS setexpr
-#line 418 "RSParserImpl.y"
+  case 86: // setexpr_binary: setexpr SYMMINUS setexpr
+#line 417 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 825 "RSParserImpl.cpp"
     break;
 
-  case 90: // setexpr_binary: setexpr SYMMINUS setexpr
-#line 419 "RSParserImpl.y"
+  case 87: // setexpr_binary: setexpr INTERSECTION setexpr
+#line 418 "RSParserImpl.y"
                                             { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 831 "RSParserImpl.cpp"
     break;
 
-  case 91: // setexpr_binary: setexpr INTERSECTION setexpr
-#line 420 "RSParserImpl.y"
-                                            { yylhs.value = BinaryOperation(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 88: // setexpr_binary: setexpr DECART setexpr
+#line 419 "RSParserImpl.y"
+                                            { yylhs.value = Decartian(yystack_[2].value, yystack_[1].value, yystack_[0].value);}
 #line 837 "RSParserImpl.cpp"
     break;
 
-  case 92: // setexpr_binary: setexpr DECART setexpr
-#line 421 "RSParserImpl.y"
-                                            { yylhs.value = Decartian(yystack_[2].value, yystack_[1].value, yystack_[0].value);}
+  case 89: // setexpr_binary: LP setexpr_binary RPE
+#line 420 "RSParserImpl.y"
+                                            { yylhs.value = RemoveBrackets(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 843 "RSParserImpl.cpp"
     break;
 
-  case 93: // setexpr_binary: LP setexpr_binary RPE
-#line 422 "RSParserImpl.y"
-                                            { yylhs.value = RemoveBrackets(yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 97: // enumeration: LC setexpr_enum RC
+#line 433 "RSParserImpl.y"
+                                            { yylhs.value = ReplaceBrackets(TokenID::NT_ENUMERATION, yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 849 "RSParserImpl.cpp"
     break;
 
-  case 101: // enumeration: LC setexpr_enum RC
-#line 435 "RSParserImpl.y"
-                                            { yylhs.value = ReplaceBrackets(TokenID::NT_ENUMERATION, yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 98: // tuple: LP setexpr_enum_min2 RPE
+#line 436 "RSParserImpl.y"
+                                            { yylhs.value = ReplaceBrackets(TokenID::NT_TUPLE, yystack_[2].value, yystack_[1].value, yystack_[0].value); }
 #line 855 "RSParserImpl.cpp"
     break;
 
-  case 102: // tuple: LP setexpr_enum_min2 RPE
-#line 438 "RSParserImpl.y"
-                                            { yylhs.value = ReplaceBrackets(TokenID::NT_TUPLE, yystack_[2].value, yystack_[1].value, yystack_[0].value); }
+  case 99: // boolean: BOOLEAN LP setexpr RPE
+#line 439 "RSParserImpl.y"
+                                            { yylhs.value = TextOperator(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 861 "RSParserImpl.cpp"
     break;
 
-  case 103: // boolean: BOOLEAN LP setexpr RPE
-#line 441 "RSParserImpl.y"
-                                            { yylhs.value = TextOperator(yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 100: // boolean: BOOLEAN boolean
+#line 440 "RSParserImpl.y"
+                                            { yylhs.value = UnaryOperation(yystack_[1].value, yystack_[0].value); }
 #line 867 "RSParserImpl.cpp"
     break;
 
-  case 104: // boolean: BOOLEAN boolean
-#line 442 "RSParserImpl.y"
-                                            { yylhs.value = UnaryOperation(yystack_[1].value, yystack_[0].value); }
+  case 101: // filter_expression: FILTER LS setexpr_enum RS LP setexpr RPE
+#line 443 "RSParserImpl.y"
+                                               { yylhs.value = FilterCall(yystack_[6].value, yystack_[4].value, yystack_[1].value, yystack_[0].value); }
 #line 873 "RSParserImpl.cpp"
     break;
 
-  case 105: // filter_expression: FILTER LS setexpr_enum RS LP setexpr RPE
-#line 445 "RSParserImpl.y"
-                                               { yylhs.value = FilterCall(yystack_[6].value, yystack_[4].value, yystack_[1].value, yystack_[0].value); }
+  case 102: // declarative: LC LOCAL IN setexpr BAR logic RCE
+#line 447 "RSParserImpl.y"
+                                            { yylhs.value = TermDeclaration(yystack_[6].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 879 "RSParserImpl.cpp"
     break;
 
-  case 106: // declarative: LC LOCAL IN setexpr BAR logic RCE
-#line 449 "RSParserImpl.y"
-                                            { yylhs.value = TermDeclaration(yystack_[6].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 103: // declarative: DECLARATIVE LC variable IN setexpr BAR logic RCE
+#line 448 "RSParserImpl.y"
+                                                       { yylhs.value = TermDeclaration(yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 885 "RSParserImpl.cpp"
     break;
 
-  case 107: // declarative: DECLARATIVE LC variable IN setexpr BAR logic RCE
-#line 450 "RSParserImpl.y"
-                                                       { yylhs.value = TermDeclaration(yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 104: // recursion: RECURSIVE LC variable ASSIGN setexpr BAR logic BAR setexpr RCE
+#line 451 "RSParserImpl.y"
+                                                                     { yylhs.value = FullRecursion(yystack_[9].value, yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 891 "RSParserImpl.cpp"
     break;
 
-  case 108: // recursion: RECURSIVE LC variable ASSIGN setexpr BAR logic BAR setexpr RCE
-#line 453 "RSParserImpl.y"
-                                                                     { yylhs.value = FullRecursion(yystack_[9].value, yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 105: // recursion: RECURSIVE LC variable ASSIGN setexpr BAR setexpr RCE
+#line 452 "RSParserImpl.y"
+                                                           { yylhs.value = ShortRecursion(yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 897 "RSParserImpl.cpp"
     break;
 
-  case 109: // recursion: RECURSIVE LC variable ASSIGN setexpr BAR setexpr RCE
-#line 454 "RSParserImpl.y"
-                                                           { yylhs.value = ShortRecursion(yystack_[7].value, yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 106: // imperative: IMPERATIVE LC setexpr BAR imp_blocks RCE
+#line 455 "RSParserImpl.y"
+                                               { yylhs.value = Imperative(yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
 #line 903 "RSParserImpl.cpp"
     break;
 
-  case 110: // imperative: IMPERATIVE LC setexpr BAR imp_blocks RCE
-#line 457 "RSParserImpl.y"
-                                               { yylhs.value = Imperative(yystack_[5].value, yystack_[3].value, yystack_[1].value, yystack_[0].value); }
+  case 107: // imp_blocks: logic
+#line 458 "RSParserImpl.y"
+                                            { yylhs.value = AddNode(TokenID::INTERRUPT, yystack_[0].value); }
 #line 909 "RSParserImpl.cpp"
     break;
 
-  case 111: // imp_blocks: imp_block
-#line 460 "RSParserImpl.y"
-                                            { yylhs.value = AddNode(TokenID::INTERRUPT, yystack_[0].value); }
+  case 108: // imp_blocks: imp_blocks SEMICOLON imp_blocks
+#line 459 "RSParserImpl.y"
+                                            { yylhs.value = Enumeration(TokenID::INTERRUPT, yystack_[2].value, yystack_[0].value); }
 #line 915 "RSParserImpl.cpp"
     break;
 
-  case 112: // imp_blocks: imp_blocks SEMICOLON imp_blocks
-#line 461 "RSParserImpl.y"
-                                            { yylhs.value = Enumeration(TokenID::INTERRUPT, yystack_[2].value, yystack_[0].value); }
+  case 110: // RPE: error
+#line 466 "RSParserImpl.y"
+            { state->OnError(ParseEID::missingParenthesis); YYABORT; }
 #line 921 "RSParserImpl.cpp"
     break;
 
-  case 113: // imp_block: LOCAL ITERATE setexpr
-#line 464 "RSParserImpl.y"
-                                            { yylhs.value = AddNode(TokenID::NT_IMP_DECLARE, yystack_[2].value, yystack_[0].value); }
+  case 112: // RCE: error
+#line 470 "RSParserImpl.y"
+            { state->OnError(ParseEID::missingCurlyBrace); YYABORT; }
 #line 927 "RSParserImpl.cpp"
     break;
 
-  case 114: // imp_block: LOCAL ASSIGN setexpr
-#line 465 "RSParserImpl.y"
-                                            { yylhs.value = AddNode(TokenID::NT_IMP_ASSIGN, yystack_[2].value, yystack_[0].value); }
-#line 933 "RSParserImpl.cpp"
-    break;
 
-  case 115: // imp_block: logic
-#line 466 "RSParserImpl.y"
-                                            { yylhs.value = AddNode(TokenID::NT_IMP_LOGIC, yystack_[0].value); }
-#line 939 "RSParserImpl.cpp"
-    break;
-
-  case 117: // RPE: error
-#line 473 "RSParserImpl.y"
-            { state->OnError(ParseEID::missingParenthesis); YYABORT; }
-#line 945 "RSParserImpl.cpp"
-    break;
-
-  case 119: // RCE: error
-#line 477 "RSParserImpl.y"
-            { state->OnError(ParseEID::missingCurlyBrace); YYABORT; }
-#line 951 "RSParserImpl.cpp"
-    break;
-
-
-#line 955 "RSParserImpl.cpp"
+#line 931 "RSParserImpl.cpp"
 
             default:
               break;
@@ -1296,199 +1272,193 @@ namespace ccl { namespace rslang { namespace detail {
   }
 
 
-  const signed char RSParserImpl::yypact_ninf_ = -115;
+  const signed char RSParserImpl::yypact_ninf_ = -60;
 
-  const signed char RSParserImpl::yytable_ninf_ = -116;
+  const signed char RSParserImpl::yytable_ninf_ = -108;
 
   const short
   RSParserImpl::yypact_[] =
   {
-     289,  -115,    83,   -21,     1,  -115,  -115,  -115,  -115,  -115,
-    -115,   395,     8,  -115,  -115,   -20,  -115,  -115,  -115,  -115,
-     -36,    -2,    42,   395,   467,    36,    46,  -115,  -115,  -115,
-      61,   161,  -115,  -115,  -115,    25,  -115,   604,    30,  -115,
-    -115,  -115,  -115,  -115,  -115,  -115,  -115,  -115,  -115,  -115,
-     395,   519,    65,   519,    65,   519,  -115,    71,    78,  -115,
-    -115,  -115,  -115,   604,   519,  -115,   519,    22,    22,   519,
-    -115,   100,   135,   604,    81,    12,   204,   140,  -115,   519,
-     326,   -38,  -115,  -115,    21,    -1,  -115,  -115,   395,   395,
-     395,   395,  -115,  -115,    28,  -115,   -12,  -115,   519,   519,
-     519,  -115,  -115,  -115,  -115,  -115,  -115,  -115,  -115,  -115,
-    -115,  -115,   519,   519,   519,   519,   519,   519,   519,  -115,
-     326,  -115,    26,  -115,    86,   143,   123,    22,   145,   107,
-     215,  -115,  -115,  -115,  -115,   519,  -115,  -115,   519,  -115,
-    -115,   519,   395,    92,    80,   177,   155,  -115,  -115,  -115,
-      19,   134,   519,    29,   115,   115,   130,  -115,  -115,  -115,
-    -115,  -115,   326,   143,  -115,  -115,  -115,   152,   519,   519,
-     447,   326,   542,   326,  -115,  -115,  -115,  -115,    37,   343,
-    -115,  -115,  -115,   519,   556,   569,   157,     7,    15,  -115,
-     395,  -115,  -115,  -115,  -115,   143,   395,   395,   519,   519,
-    -115,  -115,   447,  -115,    18,  -115,    18,   137,   253,   326,
-     326,  -115,  -115,  -115,   519,  -115,    75,  -115
+     321,    66,    22,   -29,   -28,   -60,   -60,   -60,   -60,   -60,
+     -60,   427,   -21,   -60,   -60,   -36,   -60,   -60,   -60,   -60,
+      -9,     8,    42,   427,   447,    36,    86,   -60,   -60,   -60,
+     119,   107,   156,   -60,   -60,   -60,    43,   -60,   584,    82,
+     -60,   -60,   -60,   -60,   -60,   128,   -60,   -60,   -60,   -60,
+     -60,   427,   499,    88,   499,    88,   499,   -60,   108,   129,
+     -60,   -60,   -60,   -60,   584,   499,   -60,   499,    23,    23,
+     499,   -60,    10,   112,   584,   116,     5,   217,   157,   -60,
+     499,   276,    26,   -60,   -60,   -60,    11,    40,   -60,   -60,
+     499,   499,   427,   427,   427,   427,   -60,   -60,   499,   -60,
+     -19,   -60,   499,   499,   499,   -60,   -60,   -60,   -60,   -60,
+     -60,   -60,   -60,   -60,   -60,   -60,   499,   499,   499,   499,
+     499,   499,   499,   -60,   -60,   276,   -60,    73,   -60,    84,
+      76,    93,   159,   139,   228,   -60,   -60,   -60,   -60,   499,
+     -60,   -60,   499,   -60,   -60,   499,   427,    56,   276,   276,
+      68,     4,   163,   -60,   499,    81,   127,   127,   166,   -60,
+     -60,   -60,   -60,   -60,   276,    76,   -60,   -60,   -60,   143,
+     499,   499,   427,   276,   522,   276,   -60,   -60,   -60,   375,
+     -60,   -60,   -60,   499,   536,   549,     6,    14,   427,   -60,
+      76,   427,   427,   -60,   -60,   427,   -60,    24,   -60,    24,
+     133,   266,   -60,   -60,   -60,   499,   -60,   302,   -60
   };
 
   const signed char
   RSParserImpl::yydefact_[] =
   {
-       0,    83,    80,    81,    82,    84,    77,    79,    78,    51,
-      52,     0,     0,    71,    72,     0,    73,    68,    69,    70,
+       0,    79,    76,    77,    78,    80,    73,    75,    74,    52,
+      53,     0,     0,    67,    68,     0,    69,    64,    65,    66,
        0,     0,     0,     0,     0,     0,     0,     2,     3,     4,
-      28,     0,    29,    25,    26,     0,    27,    11,     0,    62,
-      63,    64,    65,    94,    95,    96,    97,    98,   100,    99,
-       5,     0,     0,     0,     0,     0,    80,    81,    82,    50,
-      48,    49,    44,     0,     0,   104,     0,     0,     0,     0,
-      28,     0,     0,    74,     0,     0,     0,    83,    82,     0,
-      74,     0,    75,    13,     0,     0,    14,     1,     0,     0,
-       0,     0,    46,    19,     0,    53,     0,    54,     0,     0,
-       0,    40,    41,    42,    43,    39,    38,    33,    34,    35,
-      36,    37,     0,     0,     0,     0,     0,     0,     0,     7,
-       6,     8,     0,     9,     0,     0,     0,     0,     0,     0,
-       0,   117,   116,    31,    30,     0,   102,    93,     0,   101,
-      18,     0,     0,     0,    58,    59,    60,    61,    55,    23,
-       0,     0,     0,     0,    85,    86,    87,    92,    88,    91,
-      89,    90,    32,     0,    66,    47,   103,     0,     0,     0,
-       0,    76,     0,    17,    12,    16,    15,    20,     0,     0,
-      57,    56,    67,     0,     0,     0,    83,    28,     0,   111,
-       0,    22,    24,    21,    45,     0,     0,     0,     0,     0,
-     119,   118,     0,   110,     0,   105,     0,    28,     0,   114,
-     113,   112,   106,   107,     0,   109,     0,   108
+       0,    30,     0,    31,    24,    25,     0,    26,    11,     0,
+      58,    59,    60,    61,    90,    91,    92,    93,    94,    96,
+      95,     5,     0,     0,     0,     0,     0,    76,    77,    78,
+      48,    29,    27,    28,     0,     0,   100,     0,     0,     0,
+       0,    30,     0,     0,    70,     0,     0,     0,    79,    78,
+       0,    70,     0,    71,    91,    13,     0,     0,    14,     1,
+       0,     0,     0,     0,     0,     0,    50,    19,     0,    21,
+       0,    20,     0,     0,     0,    44,    45,    46,    47,    43,
+      42,    37,    38,    39,    40,    41,     0,     0,     0,     0,
+       0,     0,     0,     7,    79,     6,     8,     0,     9,     0,
+       0,     0,     0,     0,     0,   110,   109,    33,    32,     0,
+      98,    89,     0,    97,    18,     0,     0,     0,    35,    36,
+      54,    55,    56,    57,     0,     0,    81,    82,    83,    88,
+      84,    87,    85,    86,    34,     0,    62,    51,    99,     0,
+       0,     0,     0,    72,     0,    17,    12,    16,    15,     0,
+      23,    22,    63,     0,     0,     0,    30,     0,     0,    49,
+       0,     0,     0,   112,   111,     0,   106,     0,   101,     0,
+      30,     0,   108,   102,   103,     0,   105,     0,   104
   };
 
   const short
   RSParserImpl::yypgoto_[] =
   {
-    -115,  -115,  -115,   -39,    85,  -115,    66,   -34,    32,    33,
-       4,   101,    -8,    -9,  -115,    -6,    34,  -115,    59,  -115,
-     201,     0,  -115,    67,   -16,  -115,  -115,   -11,  -115,  -115,
-    -115,   213,  -115,  -115,  -115,  -115,    27,  -115,   -66,  -114
+     -60,   -60,   -60,   -41,   103,   -60,    49,   -27,    48,     2,
+      31,   114,    -7,   -10,   -60,    -6,   -60,   189,     0,   -60,
+      99,   -20,   -60,   -60,    -4,   -60,   -60,    32,   201,   -60,
+     -60,   -60,   -60,    19,   -59,   -50
   };
 
   const short
   RSParserImpl::yydefgoto_[] =
   {
-      -1,    26,    27,    28,    29,    85,    86,   149,   150,   151,
-      70,    31,    32,    33,   117,    34,    62,    35,    96,    97,
-      36,    63,    38,    74,    82,    39,    40,    41,    42,    43,
-      44,    45,    46,    47,    48,    49,   188,   189,   133,   203
+      -1,    26,    27,    28,    29,    87,    88,    30,   100,    71,
+      60,    32,    33,    34,   121,    35,    36,    37,    64,    39,
+      75,    83,    40,    41,    42,    43,    44,    84,    46,    47,
+      48,    49,    50,   187,   137,   196
   };
 
   const short
   RSParserImpl::yytable_[] =
   {
-      37,    95,    60,    59,    30,    61,   134,    75,  -115,   136,
-     137,   119,    76,   131,    71,   152,   200,   139,    67,   200,
-     131,   135,   140,    73,    80,    93,    92,    52,    93,   148,
-     180,    93,    93,   128,   129,    53,    66,    83,   191,    84,
-      93,   -28,   -28,   -28,   -28,    12,    87,   153,   141,    54,
-      37,   120,    68,    80,    30,    80,   142,    55,   143,   166,
-      64,   -10,  -115,    75,   125,   132,    80,  -115,    76,   130,
-     201,   -75,   132,   201,   127,   202,   200,    94,   -24,    80,
-     127,    94,   118,   164,   177,   135,    98,    99,   100,   127,
-     212,    81,   213,   175,   215,    84,    69,   182,   154,   155,
-     156,   131,   217,   174,    89,    90,    91,   112,   113,   114,
-     115,   116,   157,   158,   159,   160,   161,   162,   163,    95,
-     122,    25,   124,   -25,   -25,   -25,   -25,    53,   100,   205,
-     201,    50,    51,   126,    55,   171,   131,   121,   172,   123,
-     135,   173,    37,   165,   131,   135,    30,   112,   113,   114,
-     115,   116,   179,   132,    98,    99,   100,   169,   -27,   -27,
-     -27,   -27,   112,   113,   114,   115,   116,   138,   184,   185,
-      60,    59,   168,    61,   187,   112,   113,   114,   115,   116,
-     167,    91,   135,   195,    88,    89,    90,    91,   132,   144,
-     145,   146,   147,   178,   204,   214,   132,   208,   209,   210,
-     206,   207,    90,    91,   183,   131,   187,   198,   199,   176,
-     192,   193,   181,   194,   216,   -64,   -64,   -64,   -64,   -64,
-     -64,   -64,   -64,   -64,    72,    65,    98,    99,   100,   211,
-       0,   -64,   -64,   -64,   -64,   -64,   -64,   -64,   -64,   -64,
-     -64,     0,     0,     0,     0,     0,     0,   112,   113,   114,
-     115,   116,     0,     0,   200,     0,     0,   132,     0,     0,
-       0,     0,     0,   -64,    98,    99,   100,   101,   102,   103,
-     104,   105,   106,   170,     0,     0,     0,     0,     0,     0,
-     107,   108,   109,   110,   111,   112,   113,   114,   115,   116,
-       0,     0,     1,     2,     3,     4,     5,     6,     7,     8,
-       0,     0,     0,     0,     0,     0,     0,     0,   201,     9,
-      10,    11,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,     0,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    98,    99,   100,
-       0,    23,     0,    24,     0,    25,     1,    56,    57,    58,
-       5,     6,     7,     8,    98,    99,   100,     0,   112,   113,
-     114,   115,   116,     9,    10,    11,     0,     0,     0,     0,
-       0,     0,     0,     0,     0,   112,   113,   114,   115,   116,
-      12,    13,    14,    15,    16,    17,    18,    19,    20,    21,
-      22,     0,     0,     0,     0,    23,     0,    24,     1,    56,
-      57,    58,     5,     6,     7,     8,     0,     0,     0,     0,
+      38,    62,    31,    76,    61,    63,   135,  -107,   154,    99,
+     123,   135,   144,    72,   138,   193,    12,   140,   141,    77,
+      67,    53,    55,    74,    81,   193,    97,    54,    56,    94,
+      95,    65,    45,   -24,   -24,   -24,   -24,    85,   145,    86,
+     155,   132,   133,    45,    96,    68,    97,   -30,   -30,   -30,
+     -30,    38,   125,    31,    81,    45,    81,   177,   136,    86,
+      76,  -107,    69,   136,   -71,   130,  -107,    81,   101,   194,
+     134,   168,    51,    52,   195,    98,    77,   135,    76,   194,
+      81,   143,   180,    45,    97,   139,    89,   102,   103,   104,
+     148,   149,    93,    94,    95,    98,    70,   146,    81,   147,
+     101,   101,   156,   157,   158,   176,   182,   -10,   116,   117,
+     118,   119,   120,   135,   -19,   -19,   159,   160,   161,   162,
+     163,   164,   165,    82,    45,    45,    45,    45,    99,   136,
+     166,   198,   139,    98,   122,   -26,   -26,   -26,   -26,   173,
+     104,   167,   174,   139,    25,   175,    38,   203,    31,   204,
+     169,   206,   139,   127,   179,   129,   126,   208,   128,   116,
+     117,   118,   119,   120,    54,   136,   131,    90,    91,    62,
+     184,   185,    61,    63,   186,   139,   -20,   -20,    45,    92,
+      93,    94,    95,   190,   142,    56,   170,   101,   171,    95,
+     197,   205,   201,   199,   200,   183,   178,   186,   116,   117,
+     118,   119,   120,   181,    45,   207,   150,   151,   152,   153,
+     189,    45,    73,    66,   202,     0,     0,     0,   135,     0,
+      45,     0,     0,    45,    45,     0,     0,    45,   -60,   -60,
+     -60,   -60,   -60,   -60,   -60,   -60,   -60,     0,     0,   102,
+     103,   104,     0,     0,   -60,   -60,   -60,   -60,   -60,   -60,
+     -60,   -60,   -60,   -60,     0,     0,     0,     0,     0,     0,
+     116,   117,   118,   119,   120,     0,     0,   193,     0,     0,
+     136,     0,     0,     0,     0,     0,   -60,   102,   103,   104,
+     105,   106,   107,   108,   109,   110,   172,   102,   103,   104,
+       0,     0,     0,   111,   112,   113,   114,   115,   116,   117,
+     118,   119,   120,   193,     0,     0,     0,     0,   116,   117,
+     118,   119,   120,   102,   103,   104,     0,     0,     0,     0,
+       0,   194,     0,     0,     1,     2,     3,     4,     5,     6,
+       7,     8,     0,     0,   116,   117,   118,   119,   120,     0,
+       0,     9,    10,    11,     0,     0,     0,     0,     0,     0,
+       0,     0,     0,     0,     0,     0,     0,   194,    12,    13,
+      14,    15,    16,    17,    18,    19,    20,    21,    22,     0,
+       0,     0,     0,    23,     0,    24,     0,    25,     1,    57,
+      58,    59,     5,     6,     7,     8,   102,   103,   104,     0,
        0,     0,     0,     0,     0,     9,    10,    11,     0,     0,
-       0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,    12,    13,    14,    15,    16,    17,    18,    19,
+       0,     0,     0,     0,     0,     0,     0,   116,   117,   118,
+     119,   120,    12,    13,    14,    15,    16,    17,    18,    19,
       20,    21,    22,     0,     0,     0,     0,    23,     0,    24,
-     186,    56,    57,    58,     5,     6,     7,     8,     0,     0,
+       1,    57,    58,    59,     5,     6,     7,     8,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     9,    10,    11,
-      77,    56,    57,    78,     5,     6,     7,     8,     0,     0,
+      78,    57,    58,    79,     5,     6,     7,     8,     0,     0,
        0,     0,     0,     0,    12,    13,    14,    15,    16,    17,
       18,    19,    20,    21,    22,     0,     0,     0,     0,    23,
        0,    24,     0,     0,    12,    13,    14,    15,    16,    17,
-      18,    19,    20,    21,    22,     0,     0,     0,     0,    79,
-       0,    24,     1,    56,    57,    78,     5,     6,     7,     8,
+      18,    19,    20,    21,    22,     0,     0,     0,     0,    80,
+       0,    24,   124,    57,    58,    79,     5,     6,     7,     8,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
        0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
-       0,     0,     0,    98,    99,   100,    12,    13,    14,    15,
-      16,    17,    18,    19,    20,    21,    22,    98,    99,   100,
-       0,    79,     0,    24,   112,   113,   114,   115,   116,     0,
-      98,    99,   100,     0,     0,     0,     0,     0,   112,   113,
-     114,   115,   116,     0,     0,     0,     0,     0,     0,     0,
-     190,   112,   113,   114,   115,   116,     0,     0,     0,     0,
-       0,     0,     0,     0,   196,    98,    99,   100,   101,   102,
-     103,   104,   105,   106,     0,     0,     0,   197,     0,     0,
-       0,   107,   108,   109,   110,   111,   112,   113,   114,   115,
-     116
+       0,     0,     0,   102,   103,   104,    12,    13,    14,    15,
+      16,    17,    18,    19,    20,    21,    22,   102,   103,   104,
+       0,    80,     0,    24,   116,   117,   118,   119,   120,     0,
+     102,   103,   104,     0,     0,     0,     0,     0,   116,   117,
+     118,   119,   120,     0,     0,     0,     0,     0,     0,     0,
+     188,   116,   117,   118,   119,   120,     0,     0,     0,     0,
+       0,     0,     0,     0,   191,   102,   103,   104,   105,   106,
+     107,   108,   109,   110,     0,     0,     0,   192,     0,     0,
+       0,   111,   112,   113,   114,   115,   116,   117,   118,   119,
+     120
   };
 
   const short
   RSParserImpl::yycheck_[] =
   {
-       0,    35,    11,    11,     0,    11,    72,    23,     1,    75,
-      76,    50,    23,     1,    23,    27,     1,    55,    54,     1,
-       1,    59,     1,    23,    24,     3,     1,    48,     3,     1,
-       1,     3,     3,    67,    68,    56,    56,     1,     1,     3,
-       3,    23,    24,    25,    26,    37,     0,    59,    27,    48,
-      50,    51,    54,    53,    50,    55,    57,    56,    59,   125,
-      52,     0,    55,    79,    64,    53,    66,    60,    79,    69,
-      55,    59,    53,    55,    52,    60,     1,    52,    59,    79,
-      52,    52,    52,    57,   150,    59,    11,    12,    13,    52,
-     204,    24,   206,     1,   208,     3,    54,   163,    98,    99,
-     100,     1,   216,   142,    24,    25,    26,    32,    33,    34,
-      35,    36,   112,   113,   114,   115,   116,   117,   118,   153,
-      53,    56,    55,    23,    24,    25,    26,    56,    13,   195,
-      55,    48,    49,    66,    56,   135,     1,    52,   138,    54,
-      59,   141,   142,    57,     1,    59,   142,    32,    33,    34,
-      35,    36,   152,    53,    11,    12,    13,    50,    23,    24,
-      25,    26,    32,    33,    34,    35,    36,    27,   168,   169,
-     179,   179,    27,   179,   170,    32,    33,    34,    35,    36,
-      57,    26,    59,   183,    23,    24,    25,    26,    53,    88,
-      89,    90,    91,    59,   190,    58,    53,   197,   198,   199,
-     196,   197,    25,    26,    52,     1,   202,    50,    51,   143,
-     178,   178,   153,   179,   214,    11,    12,    13,    14,    15,
-      16,    17,    18,    19,    23,    12,    11,    12,    13,   202,
-      -1,    27,    28,    29,    30,    31,    32,    33,    34,    35,
-      36,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
-      35,    36,    -1,    -1,     1,    -1,    -1,    53,    -1,    -1,
-      -1,    -1,    -1,    59,    11,    12,    13,    14,    15,    16,
-      17,    18,    19,    58,    -1,    -1,    -1,    -1,    -1,    -1,
-      27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
-      -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    20,
-      21,    22,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    37,    38,    39,    40,
-      41,    42,    43,    44,    45,    46,    47,    11,    12,    13,
-      -1,    52,    -1,    54,    -1,    56,     3,     4,     5,     6,
-       7,     8,     9,    10,    11,    12,    13,    -1,    32,    33,
-      34,    35,    36,    20,    21,    22,    -1,    -1,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    32,    33,    34,    35,    36,
-      37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
-      47,    -1,    -1,    -1,    -1,    52,    -1,    54,     3,     4,
-       5,     6,     7,     8,     9,    10,    -1,    -1,    -1,    -1,
+       0,    11,     0,    23,    11,    11,     1,     1,    27,    36,
+      51,     1,     1,    23,    73,     1,    37,    76,    77,    23,
+      56,    50,    50,    23,    24,     1,     3,    56,    56,    25,
+      26,    52,     0,    23,    24,    25,    26,     1,    27,     3,
+      59,    68,    69,    11,     1,    54,     3,    23,    24,    25,
+      26,    51,    52,    51,    54,    23,    56,     1,    53,     3,
+      80,    55,    54,    53,    59,    65,    60,    67,    36,    55,
+      70,   130,    50,    51,    60,    52,    80,     1,    98,    55,
+      80,    55,     1,    51,     3,    59,     0,    11,    12,    13,
+      90,    91,    24,    25,    26,    52,    54,    57,    98,    59,
+      68,    69,   102,   103,   104,   146,   165,     0,    32,    33,
+      34,    35,    36,     1,    48,    49,   116,   117,   118,   119,
+     120,   121,   122,    24,    92,    93,    94,    95,   155,    53,
+      57,   190,    59,    52,    52,    23,    24,    25,    26,   139,
+      13,    57,   142,    59,    56,   145,   146,   197,   146,   199,
+      57,   201,    59,    54,   154,    56,    53,   207,    55,    32,
+      33,    34,    35,    36,    56,    53,    67,    48,    49,   179,
+     170,   171,   179,   179,   172,    59,    48,    49,   146,    23,
+      24,    25,    26,   183,    27,    56,    27,   155,    49,    26,
+     188,    58,   192,   191,   192,    52,   147,   195,    32,    33,
+      34,    35,    36,   155,   172,   205,    92,    93,    94,    95,
+     179,   179,    23,    12,   195,    -1,    -1,    -1,     1,    -1,
+     188,    -1,    -1,   191,   192,    -1,    -1,   195,    11,    12,
+      13,    14,    15,    16,    17,    18,    19,    -1,    -1,    11,
+      12,    13,    -1,    -1,    27,    28,    29,    30,    31,    32,
+      33,    34,    35,    36,    -1,    -1,    -1,    -1,    -1,    -1,
+      32,    33,    34,    35,    36,    -1,    -1,     1,    -1,    -1,
+      53,    -1,    -1,    -1,    -1,    -1,    59,    11,    12,    13,
+      14,    15,    16,    17,    18,    19,    58,    11,    12,    13,
+      -1,    -1,    -1,    27,    28,    29,    30,    31,    32,    33,
+      34,    35,    36,     1,    -1,    -1,    -1,    -1,    32,    33,
+      34,    35,    36,    11,    12,    13,    -1,    -1,    -1,    -1,
+      -1,    55,    -1,    -1,     3,     4,     5,     6,     7,     8,
+       9,    10,    -1,    -1,    32,    33,    34,    35,    36,    -1,
+      -1,    20,    21,    22,    -1,    -1,    -1,    -1,    -1,    -1,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    55,    37,    38,
+      39,    40,    41,    42,    43,    44,    45,    46,    47,    -1,
+      -1,    -1,    -1,    52,    -1,    54,    -1,    56,     3,     4,
+       5,     6,     7,     8,     9,    10,    11,    12,    13,    -1,
       -1,    -1,    -1,    -1,    -1,    20,    21,    22,    -1,    -1,
-      -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
-      -1,    -1,    37,    38,    39,    40,    41,    42,    43,    44,
+      -1,    -1,    -1,    -1,    -1,    -1,    -1,    32,    33,    34,
+      35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
       45,    46,    47,    -1,    -1,    -1,    -1,    52,    -1,    54,
        3,     4,     5,     6,     7,     8,     9,    10,    -1,    -1,
       -1,    -1,    -1,    -1,    -1,    -1,    -1,    20,    21,    22,
@@ -1518,25 +1488,24 @@ namespace ccl { namespace rslang { namespace detail {
        0,     3,     4,     5,     6,     7,     8,     9,    10,    20,
       21,    22,    37,    38,    39,    40,    41,    42,    43,    44,
       45,    46,    47,    52,    54,    56,    62,    63,    64,    65,
-      71,    72,    73,    74,    76,    78,    81,    82,    83,    86,
-      87,    88,    89,    90,    91,    92,    93,    94,    95,    96,
-      48,    49,    48,    56,    48,    56,     4,     5,     6,    73,
-      74,    76,    77,    82,    52,    92,    56,    54,    54,    54,
-      71,    74,    81,    82,    84,    85,    88,     3,     6,    52,
-      82,    84,    85,     1,     3,    66,    67,     0,    23,    24,
-      25,    26,     1,     3,    52,    68,    79,    80,    11,    12,
-      13,    14,    15,    16,    17,    18,    19,    27,    28,    29,
-      30,    31,    32,    33,    34,    35,    36,    75,    52,    64,
-      82,    65,    84,    65,    84,    82,    84,    52,    68,    68,
-      82,     1,    53,    99,    99,    59,    99,    99,    27,    55,
-       1,    27,    57,    59,    72,    72,    72,    72,     1,    68,
-      69,    70,    27,    59,    82,    82,    82,    82,    82,    82,
-      82,    82,    82,    82,    57,    57,    99,    57,    27,    50,
-      58,    82,    82,    82,    64,     1,    67,    99,    59,    82,
-       1,    79,    99,    52,    82,    82,     3,    71,    97,    98,
-      58,     1,    69,    70,    77,    82,    58,    58,    50,    51,
-       1,    55,    60,   100,    71,    99,    71,    71,    82,    82,
-      82,    97,   100,   100,    58,   100,    82,   100
+      68,    70,    72,    73,    74,    76,    77,    78,    79,    80,
+      83,    84,    85,    86,    87,    88,    89,    90,    91,    92,
+      93,    50,    51,    50,    56,    50,    56,     4,     5,     6,
+      71,    73,    74,    76,    79,    52,    89,    56,    54,    54,
+      54,    70,    74,    78,    79,    81,    82,    85,     3,     6,
+      52,    79,    81,    82,    88,     1,     3,    66,    67,     0,
+      48,    49,    23,    24,    25,    26,     1,     3,    52,    68,
+      69,    88,    11,    12,    13,    14,    15,    16,    17,    18,
+      19,    27,    28,    29,    30,    31,    32,    33,    34,    35,
+      36,    75,    52,    64,     3,    79,    65,    81,    65,    81,
+      79,    81,    68,    68,    79,     1,    53,    95,    95,    59,
+      95,    95,    27,    55,     1,    27,    57,    59,    79,    79,
+      72,    72,    72,    72,    27,    59,    79,    79,    79,    79,
+      79,    79,    79,    79,    79,    79,    57,    57,    95,    57,
+      27,    49,    58,    79,    79,    79,    64,     1,    67,    79,
+       1,    69,    95,    52,    79,    79,    70,    94,    58,    71,
+      79,    58,    58,     1,    55,    60,    96,    70,    95,    70,
+      70,    79,    94,    96,    96,    58,    96,    79,    96
   };
 
   const signed char
@@ -1544,16 +1513,16 @@ namespace ccl { namespace rslang { namespace detail {
   {
        0,    61,    62,    62,    62,    63,    63,    63,    63,    63,
       64,    64,    65,    65,    66,    66,    66,    67,    67,    68,
-      68,    69,    69,    70,    70,    71,    71,    71,    72,    72,
-      73,    73,    74,    75,    75,    75,    75,    75,    75,    75,
-      75,    75,    75,    75,    76,    76,    76,    76,    77,    77,
-      77,    78,    78,    79,    79,    79,    80,    80,    81,    81,
-      81,    81,    82,    82,    82,    82,    82,    82,    83,    83,
-      83,    83,    83,    83,    84,    84,    85,    86,    86,    86,
-      87,    87,    87,    87,    87,    88,    88,    88,    88,    88,
-      88,    88,    88,    88,    89,    89,    89,    89,    89,    89,
-      89,    90,    91,    92,    92,    93,    94,    94,    95,    95,
-      96,    97,    97,    98,    98,    98,    99,    99,   100,   100
+      68,    69,    69,    69,    70,    70,    70,    71,    71,    71,
+      72,    72,    73,    73,    74,    74,    74,    75,    75,    75,
+      75,    75,    75,    75,    75,    75,    75,    75,    76,    76,
+      76,    76,    77,    77,    78,    78,    78,    78,    79,    79,
+      79,    79,    79,    79,    80,    80,    80,    80,    80,    80,
+      81,    81,    82,    83,    83,    83,    84,    84,    84,    84,
+      84,    85,    85,    85,    85,    85,    85,    85,    85,    85,
+      86,    86,    86,    86,    86,    86,    86,    87,    88,    89,
+      89,    90,    91,    91,    92,    92,    93,    94,    94,    95,
+      95,    96,    96
   };
 
   const signed char
@@ -1561,16 +1530,16 @@ namespace ccl { namespace rslang { namespace detail {
   {
        0,     2,     1,     1,     1,     2,     3,     3,     3,     3,
        1,     1,     4,     2,     1,     3,     3,     3,     2,     1,
-       3,     3,     3,     1,     1,     1,     1,     1,     1,     1,
-       3,     3,     3,     1,     1,     1,     1,     1,     1,     1,
-       1,     1,     1,     1,     2,     5,     2,     4,     1,     1,
-       1,     1,     1,     1,     1,     2,     3,     3,     3,     3,
-       3,     3,     1,     1,     1,     1,     4,     4,     1,     1,
-       1,     1,     1,     1,     1,     1,     3,     1,     1,     1,
-       1,     1,     1,     1,     1,     3,     3,     3,     3,     3,
-       3,     3,     3,     3,     1,     1,     1,     1,     1,     1,
-       1,     3,     3,     4,     2,     7,     7,     8,    10,     8,
-       6,     1,     3,     3,     3,     1,     1,     1,     1,     1
+       1,     1,     3,     3,     1,     1,     1,     1,     1,     1,
+       1,     1,     3,     3,     3,     3,     3,     1,     1,     1,
+       1,     1,     1,     1,     1,     1,     1,     1,     2,     5,
+       2,     4,     1,     1,     3,     3,     3,     3,     1,     1,
+       1,     1,     4,     4,     1,     1,     1,     1,     1,     1,
+       1,     1,     3,     1,     1,     1,     1,     1,     1,     1,
+       1,     3,     3,     3,     3,     3,     3,     3,     3,     3,
+       1,     1,     1,     1,     1,     1,     1,     3,     3,     4,
+       2,     7,     7,     8,    10,     8,     6,     1,     3,     1,
+       1,     1,     1
   };
 
 
@@ -1588,17 +1557,16 @@ namespace ccl { namespace rslang { namespace detail {
   "SUBSET_OR_EQ", "NOTSUBSET", "DECART", "UNION", "INTERSECTION",
   "SET_MINUS", "SYMMINUS", "BOOLEAN", "BIGPR", "SMALLPR", "FILTER", "CARD",
   "BOOL", "DEBOOL", "RED", "DECLARATIVE", "RECURSIVE", "IMPERATIVE",
-  "DEFINE", "STRUCT", "ASSIGN", "ITERATE", "LP", "RP", "LC", "RC", "LS",
+  "ITERATE", "ASSIGN", "DEFINE", "STRUCT", "LP", "RP", "LC", "RC", "LS",
   "RS", "BAR", "COMMA", "SEMICOLON", "$accept", "expression",
   "global_declaration", "logic_or_setexpr", "function_definition",
-  "arguments", "declaration", "variable", "var_enum", "var_all", "logic",
-  "logic_all", "logic_par", "logic_predicates", "binary_predicate",
-  "logic_unary", "logic_no_binary", "quantifier", "quant_var",
-  "quant_var_enum", "logic_binary", "setexpr", "text_function",
-  "setexpr_enum", "setexpr_enum_min2", "literal", "identifier",
-  "setexpr_binary", "setexpr_generators", "enumeration", "tuple",
-  "boolean", "filter_expression", "declarative", "recursion", "imperative",
-  "imp_blocks", "imp_block", "RPE", "RCE", YY_NULLPTR
+  "arguments", "declaration", "variable", "variable_pack", "logic",
+  "logic_no_binary", "logic_all", "logic_par", "logic_predicates",
+  "binary_predicate", "logic_unary", "quantifier", "logic_binary",
+  "setexpr", "text_function", "setexpr_enum", "setexpr_enum_min2",
+  "literal", "identifier", "setexpr_binary", "setexpr_generators",
+  "enumeration", "tuple", "boolean", "filter_expression", "declarative",
+  "recursion", "imperative", "imp_blocks", "RPE", "RCE", YY_NULLPTR
   };
 #endif
 
@@ -1607,18 +1575,18 @@ namespace ccl { namespace rslang { namespace detail {
   const short
   RSParserImpl::yyrline_[] =
   {
-       0,   262,   262,   263,   264,   268,   269,   270,   271,   272,
-     276,   277,   281,   282,   287,   288,   289,   292,   293,   297,
-     298,   301,   302,   305,   306,   311,   312,   313,   316,   317,
-     320,   321,   325,   328,   329,   330,   331,   332,   333,   334,
-     335,   336,   337,   338,   342,   343,   344,   345,   348,   349,
-     350,   353,   354,   357,   358,   359,   362,   363,   367,   368,
-     369,   370,   376,   377,   378,   379,   380,   381,   384,   385,
-     386,   387,   388,   389,   392,   393,   396,   400,   401,   402,
-     406,   407,   408,   409,   410,   414,   415,   416,   417,   418,
-     419,   420,   421,   422,   426,   427,   428,   429,   430,   431,
-     432,   435,   438,   441,   442,   445,   449,   450,   453,   454,
-     457,   460,   461,   464,   465,   466,   472,   473,   476,   477
+       0,   270,   270,   271,   272,   276,   277,   278,   279,   280,
+     284,   285,   289,   290,   295,   296,   297,   300,   301,   305,
+     306,   309,   310,   311,   316,   317,   318,   321,   322,   323,
+     326,   327,   330,   331,   335,   336,   337,   340,   341,   342,
+     343,   344,   345,   346,   347,   348,   349,   350,   354,   355,
+     356,   357,   360,   361,   365,   366,   367,   368,   374,   375,
+     376,   377,   378,   379,   382,   383,   384,   385,   386,   387,
+     390,   391,   394,   398,   399,   400,   404,   405,   406,   407,
+     408,   412,   413,   414,   415,   416,   417,   418,   419,   420,
+     424,   425,   426,   427,   428,   429,   430,   433,   436,   439,
+     440,   443,   447,   448,   451,   452,   455,   458,   459,   465,
+     466,   469,   470
   };
 
   void
@@ -1703,9 +1671,9 @@ namespace ccl { namespace rslang { namespace detail {
 
 #line 15 "RSParserImpl.y"
 } } } // ccl::rslang::detail
-#line 1707 "RSParserImpl.cpp"
+#line 1675 "RSParserImpl.cpp"
 
-#line 484 "RSParserImpl.y"
+#line 477 "RSParserImpl.y"
 
 
 #ifdef _MSC_VER
diff --git a/ccl/rslang/src/RSParserImpl.y b/ccl/rslang/src/RSParserImpl.y
index 6dd2d14..9760ec5 100644
--- a/ccl/rslang/src/RSParserImpl.y
+++ b/ccl/rslang/src/RSParserImpl.y
@@ -86,8 +86,8 @@ RawNode FunctionDeclaration(
 
 RawNode FunctionCall(
     RawNode function,
-    RawNode args, RawNode
-    rs
+    RawNode args,
+    RawNode rs
 );
 
 RawNode FilterCall(
@@ -108,7 +108,12 @@ RawNode TermDeclaration(
     RawNode declaration,
     RawNode domain,
     RawNode predicate,
-    RawNode rc);
+    RawNode rc
+);
+RawNode TupleDeclaration(
+    ParserState* state,
+    RawNode tuple
+);
 
 RawNode FullRecursion(
     RawNode rec,
@@ -199,7 +204,7 @@ RawNode Imperative(
     IN              // IsElement
     NOTIN           // NotElement
     SUBSET          // IsSubset and NotEqual
-    SUBSET_OR_EQ        // IsSubset
+    SUBSET_OR_EQ    // IsSubset
     NOTSUBSET       // NotSubset
 
 
@@ -233,12 +238,15 @@ RawNode Imperative(
     IMPERATIVE      // ImperativeDefinition
 
 
+// ------------- Imperative operators -------------------
+    ITERATE         // SetIteration (IsElement)
+    ASSIGN          // Assignment (IsEqual)
+
+
 // ------------- Punctuation and Syntactic sugar ----------
 %token
     DEFINE          // Global definition separator
     STRUCT          // Global structure domain separator
-    ASSIGN          // Assignment (IsEqual)
-    ITERATE         // SetIteration (IsElement)
     LP              // (
     RP              // )
     LC              // {
@@ -260,16 +268,16 @@ RawNode Imperative(
 // ------------------------- Language Expression ------------------------------
 expression
     : global_declaration
-    | logic_or_setexpr                      { state->FinalizeExpression($1); }
-    | function_definition                   { state->FinalizeExpression($1); }
+    | logic_or_setexpr                      { if(!state->FinalizeExpression($1)) YYABORT; }
+    | function_definition                   { if(!state->FinalizeExpression($1)) YYABORT; }
     ;
 
 global_declaration
-    : GLOBAL DEFINE                         { state->FinalizeCstEmpty($1, $2); }
-    | GLOBAL STRUCT setexpr                 { state->FinalizeCstExpression($1, $2, $3); }
-    | GLOBAL DEFINE logic_or_setexpr        { state->FinalizeCstExpression($1, $2, $3); }
-    | FUNCTION DEFINE function_definition   { state->FinalizeCstExpression($1, $2, $3); }
-	| PREDICATE DEFINE function_definition  { state->FinalizeCstExpression($1, $2, $3); }
+    : GLOBAL DEFINE                         { if(!state->FinalizeCstEmpty($1, $2)) YYABORT; }
+    | GLOBAL STRUCT setexpr                 { if(!state->FinalizeCstExpression($1, $2, $3)) YYABORT; }
+    | GLOBAL DEFINE logic_or_setexpr        { if(!state->FinalizeCstExpression($1, $2, $3)) YYABORT; }
+    | FUNCTION DEFINE function_definition   { if(!state->FinalizeCstExpression($1, $2, $3)) YYABORT; }
+	| PREDICATE DEFINE function_definition  { if(!state->FinalizeCstExpression($1, $2, $3)) YYABORT; }
     ;
 
 logic_or_setexpr
@@ -295,15 +303,12 @@ declaration
 
 variable
     : LOCAL
-    | LP var_enum RPE                       { $$ = ReplaceBrackets(TokenID::NT_TUPLE_DECL, $1, $2, $3); }
+    | tuple                                 { $$ = TupleDeclaration(state, $1); if (!$$) YYABORT; }
     ;
-var_enum
-    : var_all COMMA var_all                 { $$ = Enumeration(TokenID::INTERRUPT, $1, $3); }
-    | var_all COMMA error                   { state->OnError(ParseEID::expectedLocal); YYABORT; }
-    ;
-var_all
+variable_pack
     : variable
-    | var_enum
+    | variable_pack COMMA variable_pack     { $$ = Enumeration(TokenID::NT_ENUM_DECL, $1, $3); }
+    | variable_pack COMMA error             { state->OnError(ParseEID::expectedLocal); YYABORT; }
     ;
 
 // ------------------------- Logic Expressions --------------------------------
@@ -312,6 +317,11 @@ logic
     | logic_unary
     | logic_binary
     ;
+logic_no_binary
+    : logic_predicates
+    | logic_unary
+    | logic_par
+    ;
 logic_all
     : logic
     | logic_par
@@ -323,6 +333,8 @@ logic_par
 
 logic_predicates
     : setexpr binary_predicate setexpr      { $$ = BinaryOperation($1, $2, $3); }
+    | variable ITERATE setexpr              { $$ = BinaryOperation($1, $2, $3); }
+    | variable ASSIGN setexpr               { $$ = BinaryOperation($1, $2, $3); }
     ;
 binary_predicate
     : IN
@@ -340,28 +352,14 @@ binary_predicate
 
 logic_unary
     : NOT logic_no_binary                   { $$ = UnaryOperation($1, $2);}
-    | quantifier quant_var IN setexpr logic_no_binary { $$ = Quantifier($1, $2, $4, $5);}
+    | quantifier variable_pack IN setexpr logic_no_binary { $$ = Quantifier($1, $2, $4, $5);}
     | quantifier error                      { state->OnError(ParseEID::invalidQuantifier); YYABORT; }
     | PREDICATE LS setexpr_enum RS          { $$ = FunctionCall($1, $3, $4); }    
     ;
-logic_no_binary
-    : logic_predicates
-    | logic_unary
-    | logic_par
-    ;
 quantifier
     : FORALL
     | EXISTS
     ;
-quant_var
-    : variable  
-    | quant_var_enum
-    | LP error                              { state->OnError(ParseEID::invalidQuantifier); YYABORT; }
-    ;
-quant_var_enum
-    : quant_var COMMA quant_var             { $$ = Enumeration(TokenID::NT_ENUM_DECL, $1, $3); }
-    | quant_var COMMA error                 { state->OnError(ParseEID::expectedLocal); YYABORT; }
-    ;
 
 logic_binary
     : logic_all EQUIVALENT logic_all        { $$ = BinaryOperation($1, $2, $3); }
@@ -457,14 +455,9 @@ imperative
     : IMPERATIVE LC setexpr BAR imp_blocks RCE { $$ = Imperative($1, $3, $5, $6); }
     ;
 imp_blocks
-    : imp_block                             { $$ = AddNode(TokenID::INTERRUPT, $1); }
+    : logic                                 { $$ = AddNode(TokenID::INTERRUPT, $1); }
     | imp_blocks SEMICOLON imp_blocks       { $$ = Enumeration(TokenID::INTERRUPT, $1, $3); }
     ;
-imp_block
-    : LOCAL ITERATE setexpr                 { $$ = AddNode(TokenID::NT_IMP_DECLARE, $1, $3); }
-    | LOCAL ASSIGN setexpr                  { $$ = AddNode(TokenID::NT_IMP_ASSIGN, $1, $3); }
-    | logic                                 { $$ = AddNode(TokenID::NT_IMP_LOGIC, $1); }
-    ;
 
 
 // ------------------------- Error helpers ------------------------------------
diff --git a/ccl/rslang/src/RSToken.cpp b/ccl/rslang/src/RSToken.cpp
index 4849bf3..b8bccd8 100644
--- a/ccl/rslang/src/RSToken.cpp
+++ b/ccl/rslang/src/RSToken.cpp
@@ -93,10 +93,6 @@ std::string ConvertID(std::string_view id, const Syntax syntax) {
   case TokenID::NT_IMPERATIVE_EXPR: return "IMPERATIVE";
   case TokenID::NT_RECURSIVE_FULL: return "REC_FULL";
   case TokenID::NT_RECURSIVE_SHORT: return "REC_SHORT";
-
-  case TokenID::NT_IMP_DECLARE: return "IDECLARE";
-  case TokenID::NT_IMP_ASSIGN: return "IASSIGN";
-  case TokenID::NT_IMP_LOGIC: return "ICHECK";
   }
 }
 
@@ -133,6 +129,9 @@ std::string ConvertID(std::string_view id, const Syntax syntax) {
   case TokenID::SUBSET_OR_EQ: return R"( \subseteq )";
   case TokenID::NOTSUBSET: return R"( \notsubset )";
 
+  case TokenID::ASSIGN: return R"( \assign )";
+  case TokenID::ITERATE: return R"( \from )";
+
   case TokenID::UNION: return R"( \union )";
   case TokenID::INTERSECTION: return R"( \intersect )";
   case TokenID::SET_MINUS: return R"( \setminus )";
@@ -143,8 +142,6 @@ std::string ConvertID(std::string_view id, const Syntax syntax) {
 
   case TokenID::PUNC_DEFINE: return R"( \defexpr )";
   case TokenID::PUNC_STRUCT: return R"( \deftype )";
-  case TokenID::PUNC_ASSIGN: return R"( \assign )";
-  case TokenID::PUNC_ITERATE: return R"( \from )";
   }
 }
 
@@ -174,10 +171,8 @@ std::string ConvertID(std::string_view id, const Syntax syntax) {
   case TokenID::IMPLICATION: return "\xE2\x87\x92"; // \u21D2
   case TokenID::EQUIVALENT: return "\xE2\x87\x94"; // \u21D4
 
-  case TokenID::PUNC_DEFINE: return ":==";
-  case TokenID::PUNC_STRUCT: return "::=";
-  case TokenID::PUNC_ASSIGN: return ":=";
-  case TokenID::PUNC_ITERATE: return ":\xE2\x88\x88"; // \u2208
+  case TokenID::ASSIGN: return ":=";
+  case TokenID::ITERATE: return ":\xE2\x88\x88"; // \u2208
 
   case TokenID::IN: return "\xE2\x88\x88"; // \u2208
   case TokenID::NOTIN: return "\xE2\x88\x89"; // \u2209
@@ -192,6 +187,9 @@ std::string ConvertID(std::string_view id, const Syntax syntax) {
   case TokenID::DECART: return "\xC3\x97"; // \u00D7
 
   case TokenID::BOOLEAN: return "\xE2\x84\xAC"; // \u212C
+
+  case TokenID::PUNC_DEFINE: return ":==";
+  case TokenID::PUNC_STRUCT: return "::=";
   }
 }
 
@@ -239,32 +237,36 @@ bool Token::operator==(const Token& rhs) const {
 
 std::string Token::ToString(const Syntax syntax) const {
   switch (id) {
-  default: {
-    return Str(id, syntax);
-  }
-  case TokenID::ID_LOCAL: {
-    return ConvertID(data.ToText(), syntax);
-  }
-  case TokenID::ID_GLOBAL:
-  case TokenID::ID_FUNCTION:
-  case TokenID::ID_PREDICATE:
-  case TokenID::ID_RADICAL: {
-    return data.ToText();
-  }
-  case TokenID::LIT_INTEGER: {
-    return std::to_string(data.ToInt());
-  }
-  case TokenID::BIGPR:
-  case TokenID::SMALLPR:
-  case TokenID::FILTER: {
-    const auto& indicies = data.ToTuple();
-    std::string result = Str(id) + std::to_string(*begin(indicies));
-    result += std::accumulate(next(begin(indicies)), end(indicies), std::string{},
-                             [](std::string text, const Index index) -> decltype(auto) {
-                               text += ',';
-                               text += std::to_string(index);
-                               return text;
-                             });
+    default: {
+      return Str(id, syntax);
+    }
+    case TokenID::ID_LOCAL: {
+      return ConvertID(data.ToText(), syntax);
+    }
+    case TokenID::ID_GLOBAL:
+    case TokenID::ID_FUNCTION:
+    case TokenID::ID_PREDICATE:
+    case TokenID::ID_RADICAL: {
+      return data.ToText();
+    }
+    case TokenID::LIT_INTEGER: {
+      return std::to_string(data.ToInt());
+    }
+    case TokenID::BIGPR:
+    case TokenID::SMALLPR:
+    case TokenID::FILTER: {
+      const auto& indicies = data.ToTuple();
+      std::string result = Str(id) + std::to_string(*begin(indicies));
+      result += std::accumulate(
+        next(begin(indicies)),
+        end(indicies),
+        std::string{},
+        [](std::string text, const Index index) -> decltype(auto) {
+          text += ',';
+          text += std::to_string(index);
+          return text;
+        }
+      );
     return result;
   }
   }
diff --git a/ccl/rslang/src/TypeAuditor.cpp b/ccl/rslang/src/TypeAuditor.cpp
index fa2569d..95d16ee 100644
--- a/ccl/rslang/src/TypeAuditor.cpp
+++ b/ccl/rslang/src/TypeAuditor.cpp
@@ -698,13 +698,13 @@ bool TypeAuditor::ViImperative(Cursor iter) {
   return SetCurrent(std::get<Typification>(type.value()).Bool());
 }
 
-bool TypeAuditor::ViImpDeclare(Cursor iter) {
+bool TypeAuditor::ViIterate(Cursor iter) {
   const auto domain = ChildTypeDebool(iter, 1, SemanticEID::invalidTypeOperation);
   return domain.has_value() 
     && VisitChildDeclaration(iter, 0, domain.value());
 }
 
-bool TypeAuditor::ViImpAssign(Cursor iter) {
+bool TypeAuditor::ViAssign(Cursor iter) {
   const auto domain = ChildType(iter, 1);
   return domain.has_value()
     && VisitChildDeclaration(iter, 0, std::get<Typification>(domain.value()));
diff --git a/ccl/rslang/test/src/testAST.cpp b/ccl/rslang/test/src/testAST.cpp
index 3825325..d05d832 100644
--- a/ccl/rslang/test/src/testAST.cpp
+++ b/ccl/rslang/test/src/testAST.cpp
@@ -235,6 +235,8 @@ TEST_F(UTSyntaxTree, CursorDispatchVisit) {
 }
 
 TEST_F(UTSyntaxTree, FindMinimalNode) {
+  using namespace ccl::rslang;
+
   SyntaxTree::Node root{ Token{ TokenID::AND, StrRange{0, 10} } };
   root.AddChildCopy(SyntaxTree::Node{ Token{ TokenID::OR, StrRange{0, 5} } });
   root.AddChildCopy(SyntaxTree::Node{ Token{ TokenID::BOOL, StrRange{6, 10} } });
@@ -242,15 +244,15 @@ TEST_F(UTSyntaxTree, FindMinimalNode) {
   root(0).AddChildCopy(SyntaxTree::Node{ Token{ TokenID::CARD, StrRange{4, 5} } });
 
   const SyntaxTree::Cursor cursor{root};
-  EXPECT_FALSE(ccl::rslang::FindMinimalNode(cursor, StrRange{11, 11}).has_value());
-  EXPECT_FALSE(ccl::rslang::FindMinimalNode(cursor, StrRange{-1, -1}).has_value());
-  EXPECT_FALSE(ccl::rslang::FindMinimalNode(cursor, StrRange{0, 11}).has_value());
+  EXPECT_FALSE(FindMinimalNode(cursor, StrRange{11, 11}).has_value());
+  EXPECT_FALSE(FindMinimalNode(cursor, StrRange{-1, -1}).has_value());
+  EXPECT_FALSE(FindMinimalNode(cursor, StrRange{0, 11}).has_value());
 
-  EXPECT_EQ(ccl::rslang::FindMinimalNode(cursor, StrRange{ 0, 0 }).value()->id, TokenID::BIGPR);
-  EXPECT_EQ(ccl::rslang::FindMinimalNode(cursor, StrRange{ 4, 5 }).value()->id, TokenID::CARD);
-  EXPECT_EQ(ccl::rslang::FindMinimalNode(cursor, StrRange{ 3, 4 }).value()->id, TokenID::OR);
-  EXPECT_EQ(ccl::rslang::FindMinimalNode(cursor, StrRange{ 0, 10 }).value()->id, TokenID::AND);
-  EXPECT_EQ(ccl::rslang::FindMinimalNode(cursor, StrRange{ 5, 6 }).value()->id, TokenID::AND);
+  EXPECT_EQ(FindMinimalNode(cursor, StrRange{ 0, 0 }).value()->id, TokenID::BIGPR);
+  EXPECT_EQ(FindMinimalNode(cursor, StrRange{ 4, 5 }).value()->id, TokenID::CARD);
+  EXPECT_EQ(FindMinimalNode(cursor, StrRange{ 3, 4 }).value()->id, TokenID::OR);
+  EXPECT_EQ(FindMinimalNode(cursor, StrRange{ 0, 10 }).value()->id, TokenID::AND);
+  EXPECT_EQ(FindMinimalNode(cursor, StrRange{ 5, 6 }).value()->id, TokenID::AND);
 }
 
 TEST_F(UTSyntaxTree, ASTAccess) {
diff --git a/ccl/rslang/test/src/testASTInterpreter.cpp b/ccl/rslang/test/src/testASTInterpreter.cpp
index 5e53149..686f393 100644
--- a/ccl/rslang/test/src/testASTInterpreter.cpp
+++ b/ccl/rslang/test/src/testASTInterpreter.cpp
@@ -269,6 +269,7 @@ TEST_F(UTASTInterpreter, TypedBasics) {
 }
 
 TEST_F(UTASTInterpreter, TypedExpressions) {
+  ExpectValue(R"({})", Factory::EmptySet());
   ExpectValue(R"(bool(X1))", Factory::Singleton(data.at("X1")));
   ExpectValue(R"(bool(X1 \setminus X1))", Factory::Singleton(Factory::EmptySet()));
   ExpectValue(R"(debool(bool(X1)))", data.at("X1"));
@@ -297,6 +298,7 @@ TEST_F(UTASTInterpreter, TypedExpressions) {
 
   ExpectValue(R"(I{(a,b) | a \from X1; b \assign a; b \noteq a})", Factory::EmptySet());
   ExpectValue(R"(I{a | a \from X1})", data.at("X1"));
+  ExpectValue(R"(I{a | (a,b) \from X1*X1; b \eq b})", data.at("X1"));
 
   ExpectValue(R"(R{a \assign X1 | a \setminus a})", Factory::EmptySet());
   ExpectValue(R"(R{a \assign {} | a \union X1})", data.at("X1"));
diff --git a/ccl/rslang/test/src/testASTNormalizer.cpp b/ccl/rslang/test/src/testASTNormalizer.cpp
index a45c166..5ec6594 100644
--- a/ccl/rslang/test/src/testASTNormalizer.cpp
+++ b/ccl/rslang/test/src/testASTNormalizer.cpp
@@ -6,6 +6,9 @@
 
 #include "ASTNormalizer.h"
 #include "ccl/rslang/Parser.h"
+#include "ccl/rslang/Literals.h"
+
+using ccl::operator""_c17;
 
 class UTastNormalize : public ::testing::Test {
 protected:
@@ -36,31 +39,78 @@ void UTastNormalize::ExpectAST(const std::string& input, const std::string& ast)
 }
 
 TEST_F(UTastNormalize, EnumDeclaration) {
-  ExpectAST(R"(\A a,b \in X1 a \eq b)", "[\xE2\x88\x80[a][X1][\xE2\x88\x80[b][X1][=[a][b]]]]");
-  ExpectAST(R"(\E a,b \in X1 a \eq b)", "[\xE2\x88\x83[a][X1][\xE2\x88\x83[b][X1][=[a][b]]]]");
-  ExpectAST(R"(\E a,b,c \in X1 a \eq b)", "[\xE2\x88\x83[a][X1][\xE2\x88\x83[b][X1][\xE2\x88\x83[c][X1][=[a][b]]]]]");
+  ExpectAST(
+    R"(\A a,b \in X1 a \eq b)",
+    u8"[\u2200[a][X1][\u2200[b][X1][=[a][b]]]]"_c17
+  );
+  ExpectAST(
+    R"(\E a,b \in X1 a \eq b)",
+    u8"[\u2203[a][X1][\u2203[b][X1][=[a][b]]]]"_c17
+  );
+  ExpectAST(
+    R"(\E a,b,c \in X1 a \eq b)",
+    u8"[\u2203[a][X1][\u2203[b][X1][\u2203[c][X1][=[a][b]]]]]"_c17
+  );
 }
 
 TEST_F(UTastNormalize, Quantor) {
-  ExpectAST(R"(\A (a,b) \in S1 a \eq b)", "[\xE2\x88\x80[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]");
-  ExpectAST(R"(\E (a,b) \in S1 a \eq b)", "[\xE2\x88\x83[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]");
-  ExpectAST(R"(\E (a,b,c) \in S1 (a \eq b \and b \eq c))", 
-            "[\xE2\x88\x83[@abc][S1][&[=[pr1[@abc]][pr2[@abc]]][=[pr2[@abc]][pr3[@abc]]]]]");
-  ExpectAST(R"(\E (a,(b,c)) \in S1 (a \eq b \and b \eq c))", 
-            "[\xE2\x88\x83[@abc][S1][&[=[pr1[@abc]][pr1[pr2[@abc]]]][=[pr1[pr2[@abc]]][pr2[pr2[@abc]]]]]]");
+  ExpectAST(
+    R"(\A (a,b) \in S1 a \eq b)",
+    u8"[\u2200[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]"_c17
+  );
+  ExpectAST(
+    R"(\E (a,b) \in S1 a \eq b)",
+    u8"[\u2203[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]"_c17
+  );
+  ExpectAST(
+    R"(\E (a,b,c) \in S1 (a \eq b \and b \eq c))", 
+    u8"[\u2203[@abc][S1][&[=[pr1[@abc]][pr2[@abc]]][=[pr2[@abc]][pr3[@abc]]]]]"_c17
+  );
+  ExpectAST(
+    R"(\E (a,(b,c)) \in S1 (a \eq b \and b \eq c))", 
+    u8"[\u2203[@abc][S1][&[=[pr1[@abc]][pr1[pr2[@abc]]]][=[pr1[pr2[@abc]]][pr2[pr2[@abc]]]]]]"_c17
+  );
 }
 
 TEST_F(UTastNormalize,TermTupleDeclaration) {
-  ExpectAST(R"(D{(a,b) \in S1 | a \eq b})", "[DECLARATIVE[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]");
-  ExpectAST(R"(D{(a,b,c) \in S1 | a \eq b \and b \eq c})", 
-            "[DECLARATIVE[@abc][S1][&[=[pr1[@abc]][pr2[@abc]]][=[pr2[@abc]][pr3[@abc]]]]]");
-  ExpectAST(R"(D{(a,(b,c)) \in S1 | a \eq b \and b \eq c})", 
-            "[DECLARATIVE[@abc][S1][&[=[pr1[@abc]][pr1[pr2[@abc]]]][=[pr1[pr2[@abc]]][pr2[pr2[@abc]]]]]]");
+  ExpectAST(
+    R"(D{(a,b) \in S1 | a \eq b})",
+    "[DECLARATIVE[@ab][S1][=[pr1[@ab]][pr2[@ab]]]]"
+  );
+  ExpectAST(
+    R"(D{(a,b,c) \in S1 | a \eq b \and b \eq c})", 
+    "[DECLARATIVE[@abc][S1][&[=[pr1[@abc]][pr2[@abc]]][=[pr2[@abc]][pr3[@abc]]]]]"
+  );
+  ExpectAST(
+    R"(D{(a,(b,c)) \in S1 | a \eq b \and b \eq c})", 
+    "[DECLARATIVE[@abc][S1][&[=[pr1[@abc]][pr1[pr2[@abc]]]][=[pr1[pr2[@abc]]][pr2[pr2[@abc]]]]]]"
+  );
+}
+
+TEST_F(UTastNormalize, Imperative) {
+  ExpectAST(
+    R"(I{(b,a) | (a,b) \from S1})",
+    u8"[IMPERATIVE[TUPLE[pr2[@ab]][pr1[@ab]]][:\u2208[@ab][S1]]]"_c17
+  );
+  ExpectAST(
+    R"(I{b | (a,b) \from S1; a \eq a})",
+    u8"[IMPERATIVE[pr2[@ab]][:\u2208[@ab][S1]][=[pr1[@ab]][pr1[@ab]]]]"_c17
+  );
+  ExpectAST(
+    R"(I{(c,b) | a \from {S1}; (b,c) \assign a})",
+    u8"[IMPERATIVE[TUPLE[pr2[@bc]][pr1[@bc]]][:\u2208[a][SET[S1]]][:=[@bc][a]]]"_c17
+  );
 }
 
 TEST_F(UTastNormalize, RecrusionTupleDeclaration) {
-  ExpectAST(R"(R{(a,b) \assign S1 | (b,a)})", "[REC_SHORT[@ab][S1][TUPLE[pr2[@ab]][pr1[@ab]]]]");
-  ExpectAST(R"(R{(a,b) \assign S1 | 1 \eq 1 | (b,a)})", "[REC_FULL[@ab][S1][=[1][1]][TUPLE[pr2[@ab]][pr1[@ab]]]]");
+  ExpectAST(
+    R"(R{(a,b) \assign S1 | (b,a)})",
+    "[REC_SHORT[@ab][S1][TUPLE[pr2[@ab]][pr1[@ab]]]]"
+  );
+  ExpectAST(
+    R"(R{(a,b) \assign S1 | 1 \eq 1 | (b,a)})",
+    "[REC_FULL[@ab][S1][=[1][1]][TUPLE[pr2[@ab]][pr1[@ab]]]]"
+  );
 }
 
 TEST_F(UTastNormalize, Functions) {
@@ -68,7 +118,16 @@ TEST_F(UTastNormalize, Functions) {
   ExpectAST(R"(F1[X1 \setminus X1])", "[SET[\\[X1][X1]]]");
   ExpectAST(R"(F1[F1[X1]])", "[SET[SET[X1]]]");
   ExpectAST(R"(F2[X1, X2])", "[TUPLE[X1][X2]]");
-  ExpectAST(R"(F3[X1])", "[DECLARATIVE[__var1][X1][=[__var1][__var1]]]");
-  ExpectAST(R"(F3[F3[X1]])", "[DECLARATIVE[__var1][DECLARATIVE[__var2][X1][=[__var2][__var2]]][=[__var1][__var1]]]");
-  ExpectAST(R"(\A t \in X1 F3[{t}] \eq t)", "[\xE2\x88\x80[t][X1][=[DECLARATIVE[__var1][SET[t]][=[__var1][__var1]]][t]]]");
+  ExpectAST(
+    R"(F3[X1])",
+    "[DECLARATIVE[__var1][X1][=[__var1][__var1]]]"
+  );
+  ExpectAST(
+    R"(F3[F3[X1]])",
+    "[DECLARATIVE[__var1][DECLARATIVE[__var2][X1][=[__var2][__var2]]][=[__var1][__var1]]]"
+  );
+  ExpectAST(
+    R"(\A t \in X1 F3[{t}] \eq t)",
+    u8"[\u2200[t][X1][=[DECLARATIVE[__var1][SET[t]][=[__var1][__var1]]][t]]]"_c17
+  );
 }
\ No newline at end of file
diff --git a/ccl/rslang/test/src/testAsciiLexer.cpp b/ccl/rslang/test/src/testAsciiLexer.cpp
index cb174a5..8f4f0dc 100644
--- a/ccl/rslang/test/src/testAsciiLexer.cpp
+++ b/ccl/rslang/test/src/testAsciiLexer.cpp
@@ -71,7 +71,7 @@ TEST_F(UTAsciiLexer, Keywords) {
   TestSingle(R"(\and)", TokenID::AND);
   TestSingle(R"(\or)", TokenID::OR);
 
-  TestSingle(R"(\from)", TokenID::PUNC_ITERATE);
+  TestSingle(R"(\from)", TokenID::ITERATE);
   TestSingle(R"(\in)", TokenID::IN);
   TestSingle(R"(\notin)", TokenID::NOTIN);
   TestSingle(R"(\subseteq)", TokenID::SUBSET_OR_EQ);
diff --git a/ccl/rslang/test/src/testLiterals.cpp b/ccl/rslang/test/src/testLiterals.cpp
index ced5f83..f257274 100644
--- a/ccl/rslang/test/src/testLiterals.cpp
+++ b/ccl/rslang/test/src/testLiterals.cpp
@@ -3,6 +3,9 @@
 #include "gtest/gtest.h"
 
 #include "FakeRSEnvironment.hpp"
+#include "ccl/rslang/Literals.h"
+
+using ccl::operator""_c17;
 
 class UTLiterals: public ::testing::Test {
 protected:
@@ -13,6 +16,7 @@ protected:
 TEST_F(UTLiterals, TypificationLiteral) {
   EXPECT_EQ(Typification("X1"), "X1"_t);
   EXPECT_EQ(Typification("C1"), "C1"_t);
+  EXPECT_EQ(Typification::EmptySet(), "B(R0)"_t);
   EXPECT_EQ(Typification::Integer(), "Z"_t);
   EXPECT_EQ(Typification("X1").Bool(), "B(X1)"_t);
   EXPECT_EQ(Typification("X1").Bool().Bool(), "BB(X1)"_t);
@@ -21,7 +25,12 @@ TEST_F(UTLiterals, TypificationLiteral) {
 }
 
 TEST_F(UTLiterals, RSlangLiteral) {
-  using ccl::operator""_c17;
-  EXPECT_EQ(R"(S1 \in B(X1))"_rs, u8"S1\u2208\u212C(X1)"_c17);
-  EXPECT_EQ("B(Y*(X1*X2)*BB(X3))"_rs, u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17);
+  EXPECT_EQ(
+    R"(S1 \in B(X1))"_rs,
+    u8"S1\u2208\u212C(X1)"_c17
+  );
+  EXPECT_EQ(
+    "B(Y*(X1*X2)*BB(X3))"_rs,
+    u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17
+  );
 }
\ No newline at end of file
diff --git a/ccl/rslang/test/src/testLogger.cpp b/ccl/rslang/test/src/testLogger.cpp
index 5fe4094..be7e4f7 100644
--- a/ccl/rslang/test/src/testLogger.cpp
+++ b/ccl/rslang/test/src/testLogger.cpp
@@ -13,11 +13,12 @@ protected:
 };
 
 TEST_F(UTLogger, ResolveErrorType) {
-  EXPECT_EQ(ccl::rslang::ResolveErrorType(static_cast<uint32_t>(ErrorStatus::WARNING)), ErrorStatus::WARNING);
-  EXPECT_EQ(ccl::rslang::ResolveErrorType(static_cast<uint32_t>(ErrorStatus::WARNING) + 1), ErrorStatus::WARNING);
-  EXPECT_EQ(ccl::rslang::ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL)), ErrorStatus::CRITICAL);
-  EXPECT_EQ(ccl::rslang::ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL) + 1), ErrorStatus::CRITICAL);
-  EXPECT_EQ(ccl::rslang::ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL) - 1), ErrorStatus::WARNING);
+  using namespace ccl::rslang;
+  EXPECT_EQ(ResolveErrorType(static_cast<uint32_t>(ErrorStatus::WARNING)), ErrorStatus::WARNING);
+  EXPECT_EQ(ResolveErrorType(static_cast<uint32_t>(ErrorStatus::WARNING) + 1), ErrorStatus::WARNING);
+  EXPECT_EQ(ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL)), ErrorStatus::CRITICAL);
+  EXPECT_EQ(ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL) + 1), ErrorStatus::CRITICAL);
+  EXPECT_EQ(ResolveErrorType(static_cast<uint32_t>(ErrorStatus::CRITICAL) - 1), ErrorStatus::WARNING);
 
   EXPECT_TRUE(Error(static_cast<uint32_t>(ErrorStatus::WARNING), 0).IsWarning());
   EXPECT_FALSE(Error(static_cast<uint32_t>(ErrorStatus::WARNING), 0).IsCritical());
diff --git a/ccl/rslang/test/src/testMathLexer.cpp b/ccl/rslang/test/src/testMathLexer.cpp
index 872e2f0..1a50880 100644
--- a/ccl/rslang/test/src/testMathLexer.cpp
+++ b/ccl/rslang/test/src/testMathLexer.cpp
@@ -91,8 +91,8 @@ TEST_F(UTMathLexer, SingleSymbol) {
   TestSingle(u8"\u00D7"_c17, TokenID::DECART, 1);
   TestSingle("\xE2\x84\xAC", TokenID::BOOLEAN, 1);
 
-  TestToken(u8":\u2208"_c17, TokenID::PUNC_ITERATE);
-  TestSingle(":=", TokenID::PUNC_ASSIGN);
+  TestToken(u8":\u2208"_c17, TokenID::ITERATE);
+  TestSingle(":=", TokenID::ASSIGN);
   TestSingle(":==", TokenID::PUNC_DEFINE);
   TestSingle("::=", TokenID::PUNC_STRUCT);
 }
diff --git a/ccl/rslang/test/src/testRSExpr.cpp b/ccl/rslang/test/src/testRSExpr.cpp
index 3269b1e..b31aef3 100644
--- a/ccl/rslang/test/src/testRSExpr.cpp
+++ b/ccl/rslang/test/src/testRSExpr.cpp
@@ -69,7 +69,11 @@ TEST_F(UTRSExpr, FilterIDs) {
 TEST_F(UTRSExpr, Translate) {
   using ccl::operator""_c17;
   std::string input{ u8"\u212C X1 X2 ab ba"_c17 };
-  const auto repCount = ccl::rslang::TranslateRS(input, TFFactory::FilterIdentifiers(), ccl::CreateTranslator(idMap));
+  const auto repCount = ccl::rslang::TranslateRS(
+    input,
+    TFFactory::FilterIdentifiers(),
+    ccl::CreateTranslator(idMap)
+  );
   EXPECT_EQ(repCount, 2);
   EXPECT_EQ(input, u8"\u212C X42 X2 ba ba"_c17);
 }
diff --git a/ccl/rslang/test/src/testRSGenerator.cpp b/ccl/rslang/test/src/testRSGenerator.cpp
index c59bf01..1b610a6 100644
--- a/ccl/rslang/test/src/testRSGenerator.cpp
+++ b/ccl/rslang/test/src/testRSGenerator.cpp
@@ -6,6 +6,7 @@
 
 #include "ccl/rslang/RSGenerator.h"
 #include "ccl/rslang/Parser.h"
+#include "ccl/rslang/Literals.h"
 
 using ccl::operator""_c17;
 
@@ -71,9 +72,18 @@ TEST_F(UTRSGenerator, ExtractPrefix) {
 }
 
 TEST_F(UTRSGenerator, FromASTGlobal) {
-  ExpectASTGeneration("X1:== ", "X1:==");
-  ExpectASTGeneration("D1:==X1\\X2", "D1:==X1\\X2");
-  ExpectASTGeneration(u8"F1:==[a\u2208X1]a \\ a"_c17, u8"F1:==[a\u2208X1] a\\a"_c17);
+  ExpectASTGeneration(
+    "X1:== ",
+    "X1:=="
+  );
+  ExpectASTGeneration(
+    "D1:==X1\\X2",
+    "D1:==X1\\X2"
+  );
+  ExpectASTGeneration(
+    u8"F1:==[a\u2208X1]a \\ a"_c17,
+    u8"F1:==[a\u2208X1] a\\a"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, FromASTInteger) {
@@ -86,12 +96,30 @@ TEST_F(UTRSGenerator, FromASTInteger) {
   ExpectASTGeneration("1 +2*3", "1+2*3");
   ExpectASTGeneration("(1+2) * 3", "(1+2)*3");
 
-  ExpectASTGeneration("1 = 2", "1=2");
-  ExpectASTGeneration(u8"1 \u2260 2"_c17, u8"1\u22602"_c17);
-  ExpectASTGeneration("1 > 2", "1>2");
-  ExpectASTGeneration("1 < 2", "1<2");
-  ExpectASTGeneration(u8"1 \u2264 2"_c17, u8"1\u22642"_c17);
-  ExpectASTGeneration(u8"1 \u2265 2"_c17, u8"1\u22652"_c17);
+  ExpectASTGeneration(
+    "1 = 2",
+    "1=2"
+  );
+  ExpectASTGeneration(
+    u8"1 \u2260 2"_c17,
+    u8"1\u22602"_c17
+  );
+  ExpectASTGeneration(
+    "1 > 2",
+    "1>2"
+  );
+  ExpectASTGeneration(
+    "1 < 2",
+    "1<2"
+  );
+  ExpectASTGeneration(
+    u8"1 \u2264 2"_c17,
+    u8"1\u22642"_c17
+  );
+  ExpectASTGeneration(
+    u8"1 \u2265 2"_c17,
+    u8"1\u22652"_c17
+  );
 
   ExpectASTGeneration("1+2=3", "1+2=3");
   ExpectASTGeneration("1-2=3", "1-2=3");
@@ -102,42 +130,129 @@ TEST_F(UTRSGenerator, FromASTInteger) {
 }
 
 TEST_F(UTRSGenerator, FromASTLogic) {
-  ExpectASTGeneration(u8"\u00AC (1=2 & 3=4)"_c17, u8"\u00AC(1=2 & 3=4)"_c17);
-  ExpectASTGeneration(u8"\u00AC (1=2 \u2228 3=4)"_c17, u8"\u00AC(1=2 \u2228 3=4)"_c17);
-  ExpectASTGeneration(u8"\u00AC (1=2 \u21D2 3=4)"_c17, u8"\u00AC(1=2 \u21D2 3=4)"_c17);
-  ExpectASTGeneration(u8"\u00AC (1=2 \u21D4 3=4)"_c17, u8"\u00AC(1=2 \u21D4 3=4)"_c17);
+  ExpectASTGeneration(
+    u8"\u00AC (1=2 & 3=4)"_c17,
+    u8"\u00AC(1=2 & 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u00AC (1=2 \u2228 3=4)"_c17,
+    u8"\u00AC(1=2 \u2228 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u00AC (1=2 \u21D2 3=4)"_c17,
+    u8"\u00AC(1=2 \u21D2 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u00AC (1=2 \u21D4 3=4)"_c17,
+    u8"\u00AC(1=2 \u21D4 3=4)"_c17
+  );
 
-  ExpectASTGeneration("1=2 & (3=4 & 5=6)", "1=2 & (3=4 & 5=6)");
-  ExpectASTGeneration(u8"1=2 \u2228 (3=4 \u2228 5=6)"_c17, u8"1=2 \u2228 (3=4 \u2228 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 \u21D2 (3=4 \u21D2 5=6)"_c17, u8"1=2 \u21D2 (3=4 \u21D2 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 \u21D4 (3=4 \u21D4 5=6)"_c17, u8"1=2 \u21D4 (3=4 \u21D4 5=6)"_c17);
+  ExpectASTGeneration(
+    "1=2 & (3=4 & 5=6)",
+    "1=2 & (3=4 & 5=6)"
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u2228 (3=4 \u2228 5=6)"_c17,
+    u8"1=2 \u2228 (3=4 \u2228 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u21D2 (3=4 \u21D2 5=6)"_c17,
+    u8"1=2 \u21D2 (3=4 \u21D2 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u21D4 (3=4 \u21D4 5=6)"_c17,
+    u8"1=2 \u21D4 (3=4 \u21D4 5=6)"_c17
+  );
 
-  ExpectASTGeneration(u8"1=2 & (3=4 \u2228 5=6)"_c17, u8"1=2 & (3=4 \u2228 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 & (3=4 \u21D2 5=6)"_c17, u8"1=2 & (3=4 \u21D2 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 & (3=4 \u21D4 5=6)"_c17, u8"1=2 & (3=4 \u21D4 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 \u2228 (3=4 \u21D2 5=6)"_c17, u8"1=2 \u2228 (3=4 \u21D2 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 \u2228 (3=4 \u21D4 5=6)"_c17, u8"1=2 \u2228 (3=4 \u21D4 5=6)"_c17);
-  ExpectASTGeneration(u8"1=2 \u21D2 (3=4 \u21D4 5=6)"_c17, u8"1=2 \u21D2 (3=4 \u21D4 5=6)"_c17);
+  ExpectASTGeneration(
+    u8"1=2 & (3=4 \u2228 5=6)"_c17,
+    u8"1=2 & (3=4 \u2228 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 & (3=4 \u21D2 5=6)"_c17,
+    u8"1=2 & (3=4 \u21D2 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 & (3=4 \u21D4 5=6)"_c17,
+    u8"1=2 & (3=4 \u21D4 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u2228 (3=4 \u21D2 5=6)"_c17,
+    u8"1=2 \u2228 (3=4 \u21D2 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u2228 (3=4 \u21D4 5=6)"_c17,
+    u8"1=2 \u2228 (3=4 \u21D4 5=6)"_c17
+  );
+  ExpectASTGeneration(
+    u8"1=2 \u21D2 (3=4 \u21D4 5=6)"_c17,
+    u8"1=2 \u21D2 (3=4 \u21D4 5=6)"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, FromASTQuantifier) {
-  ExpectASTGeneration(u8"\u2200a\u2208X1 (1=2)"_c17, u8"\u2200a\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2203a\u2208X1 (1=2)"_c17, u8"\u2203a\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2200a,b\u2208X1 (1=2)"_c17, u8"\u2200a, b\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 1=2 & 3=4"_c17, u8"\u2200a\u2208X1 1=2 & 3=4"_c17);
-  ExpectASTGeneration(u8"\u2200b\u2208X1\u2200a\u2208X1 1=2"_c17, u8"\u2200b\u2208X1 \u2200a\u2208X1 1=2"_c17);
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 (1=2)"_c17,
+    u8"\u2200a\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2203a\u2208X1 (1=2)"_c17,
+    u8"\u2203a\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a,b\u2208X1 (1=2)"_c17,
+    u8"\u2200a, b\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 1=2 & 3=4"_c17,
+    u8"\u2200a\u2208X1 1=2 & 3=4"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200b\u2208X1\u2200a\u2208X1 1=2"_c17,
+    u8"\u2200b\u2208X1 \u2200a\u2208X1 1=2"_c17
+  );
 
-  ExpectASTGeneration(u8"\u00AC\u2200a\u2208X1 1=2"_c17, u8"\u00AC\u2200a\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 \u00AC1=2"_c17, u8"\u2200a\u2208X1 \u00AC1=2"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 (1=2 & 3=4)"_c17, u8"\u2200a\u2208X1 (1=2 & 3=4)"_c17);
-  ExpectASTGeneration(u8"\u2203a\u2208X1 (1=2 & 3=4)"_c17, u8"\u2203a\u2208X1 (1=2 & 3=4)"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 (1=2 \u2228 3=4)"_c17, u8"\u2200a\u2208X1 (1=2 \u2228 3=4)"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 (1=2 \u21D2 3=4)"_c17, u8"\u2200a\u2208X1 (1=2 \u21D2 3=4)"_c17);
-  ExpectASTGeneration(u8"\u2200a\u2208X1 (1=2 \u21D4 3=4)"_c17, u8"\u2200a\u2208X1 (1=2 \u21D4 3=4)"_c17);
+  ExpectASTGeneration(
+    u8"\u00AC\u2200a\u2208X1 1=2"_c17,
+    u8"\u00AC\u2200a\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 \u00AC1=2"_c17,
+    u8"\u2200a\u2208X1 \u00AC1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 (1=2 & 3=4)"_c17,
+    u8"\u2200a\u2208X1 (1=2 & 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2203a\u2208X1 (1=2 & 3=4)"_c17,
+    u8"\u2203a\u2208X1 (1=2 & 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 (1=2 \u2228 3=4)"_c17,
+    u8"\u2200a\u2208X1 (1=2 \u2228 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 (1=2 \u21D2 3=4)"_c17,
+    u8"\u2200a\u2208X1 (1=2 \u21D2 3=4)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200a\u2208X1 (1=2 \u21D4 3=4)"_c17,
+    u8"\u2200a\u2208X1 (1=2 \u21D4 3=4)"_c17
+  );
 
-  ExpectASTGeneration(u8"\u2200(a,b)\u2208X1 1=2"_c17, u8"\u2200(a, b)\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2200(a,b,c)\u2208X1 1=2"_c17, u8"\u2200(a, b, c)\u2208X1 1=2"_c17);
-  ExpectASTGeneration(u8"\u2200(a,(b,c))\u2208X1 1=2"_c17, u8"\u2200(a, (b, c))\u2208X1 1=2"_c17);
+  ExpectASTGeneration(
+    u8"\u2200(a,b)\u2208X1 1=2"_c17,
+    u8"\u2200(a, b)\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200(a,b,c)\u2208X1 1=2"_c17,
+    u8"\u2200(a, b, c)\u2208X1 1=2"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u2200(a,(b,c))\u2208X1 1=2"_c17,
+    u8"\u2200(a, (b, c))\u2208X1 1=2"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, FromASTTyped) {
@@ -146,56 +261,182 @@ TEST_F(UTRSGenerator, FromASTTyped) {
   ExpectASTGeneration("F1[a]", "F1[a]");
   ExpectASTGeneration("F1[S1 , S2 , S3]", "F1[S1, S2, S3]");
 
-  ExpectASTGeneration(u8"X1 \u2208 X2"_c17, u8"X1\u2208X2"_c17);
-  ExpectASTGeneration(u8"X1 \u2209 X2"_c17, u8"X1\u2209X2"_c17);
-  ExpectASTGeneration(u8"X1 \u2282 X2"_c17, u8"X1\u2282X2"_c17);
-  ExpectASTGeneration(u8"X1 \u2286 X2"_c17, u8"X1\u2286X2"_c17);
-  ExpectASTGeneration(u8"X1 \u2284 X2"_c17, u8"X1\u2284X2"_c17);
+  ExpectASTGeneration(
+    u8"X1 \u2208 X2"_c17,
+    u8"X1\u2208X2"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1 \u2209 X2"_c17,
+    u8"X1\u2209X2"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1 \u2282 X2"_c17,
+    u8"X1\u2282X2"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1 \u2286 X2"_c17,
+    u8"X1\u2286X2"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1 \u2284 X2"_c17,
+    u8"X1\u2284X2"_c17
+  );
 
-  ExpectASTGeneration(u8"\u212C\u212C( X1 )"_c17, u8"\u212C\u212C(X1)"_c17);
-  ExpectASTGeneration(u8"\u212C(\u212C( X1 ))"_c17, u8"\u212C\u212C(X1)"_c17);
-  ExpectASTGeneration("Pr1( S1 )", "Pr1(S1)");
-  ExpectASTGeneration("Pr42( S1 )", "Pr42(S1)");
-  ExpectASTGeneration("pr1( a )", "pr1(a)");
-  ExpectASTGeneration("Fi1,2[ b, c]( a )", "Fi1,2[b, c](a)");
-  ExpectASTGeneration("pr42( a )", "pr42(a)");
-  ExpectASTGeneration("bool( a )", "bool(a)");
-  ExpectASTGeneration("debool( a )", "debool(a)");
-  ExpectASTGeneration("red( a )", "red(a)");
+  ExpectASTGeneration(
+    u8"\u212C\u212C( X1 )"_c17,
+    u8"\u212C\u212C(X1)"_c17
+  );
+  ExpectASTGeneration(
+    u8"\u212C(\u212C( X1 ))"_c17,
+    u8"\u212C\u212C(X1)"_c17
+  );
+  ExpectASTGeneration(
+    "Pr1( S1 )",
+    "Pr1(S1)"
+  );
+  ExpectASTGeneration(
+    "Pr42( S1 )",
+    "Pr42(S1)"
+  );
+  ExpectASTGeneration(
+    "pr1( a )",
+    "pr1(a)"
+  );
+  ExpectASTGeneration(
+    "Fi1,2[ b, c]( a )",
+    "Fi1,2[b, c](a)"
+  );
+  ExpectASTGeneration(
+    "pr42( a )",
+    "pr42(a)"
+  );
+  ExpectASTGeneration(
+    "bool( a )",
+    "bool(a)"
+  );
+  ExpectASTGeneration(
+    "debool( a )",
+    "debool(a)"
+  );
+  ExpectASTGeneration(
+    "red( a )",
+    "red(a)"
+  );
 
-  ExpectASTGeneration("(a,b)", "(a, b)");
-  ExpectASTGeneration("(a,b,c)", "(a, b, c)");
-  ExpectASTGeneration("{a}", "{a}");
-  ExpectASTGeneration("{a, b}", "{a, b}");
-  ExpectASTGeneration("{a,b,c}", "{a, b, c}");
-  ExpectASTGeneration("{(a,b),c}", "{(a, b), c}");
+  ExpectASTGeneration(
+    "(a,b)",
+    "(a, b)"
+  );
+  ExpectASTGeneration(
+    "(a,b,c)",
+    "(a, b, c)"
+  );
+  ExpectASTGeneration(
+    "{a}",
+    "{a}"
+  );
+  ExpectASTGeneration(
+    "{a, b}",
+    "{a, b}"
+  );
+  ExpectASTGeneration(
+    "{a,b,c}",
+    "{a, b, c}"
+  );
+  ExpectASTGeneration(
+    "{(a,b),c}",
+    "{(a, b), c}"
+  );
 
-  ExpectASTGeneration(u8"{a \u2208 X1|1=2}"_c17, u8"D{a\u2208X1 | 1=2}"_c17);
-  ExpectASTGeneration(u8"D{(a,b) \u2208 X1|1=2}"_c17, u8"D{(a, b)\u2208X1 | 1=2}"_c17);
-  ExpectASTGeneration(u8"D{(a,b,c) \u2208 X1|1=2}"_c17, u8"D{(a, b, c)\u2208X1 | 1=2}"_c17);
-  ExpectASTGeneration(u8"D{(a,(b,c)) \u2208 X1|1=2}"_c17, u8"D{(a, (b, c))\u2208X1 | 1=2}"_c17);
-  ExpectASTGeneration(u8"D{((a,b),c) \u2208 X1|1=2}"_c17, u8"D{((a, b), c)\u2208X1 | 1=2}"_c17);
-  ExpectASTGeneration("R{a:=X1 | 1=1| a \\ a}", "R{a:=X1 | 1=1 | a\\a}");
-  ExpectASTGeneration(u8"I{ (a,b) | b:\u2208X1; a:= b; 1=1}"_c17, u8"I{(a, b) | b:\u2208X1; a:=b; 1=1}"_c17);
+  ExpectASTGeneration(
+    u8"{a \u2208 X1|1=2}"_c17,
+    u8"D{a\u2208X1 | 1=2}"_c17
+  );
+  ExpectASTGeneration(
+    u8"D{(a,b) \u2208 X1|1=2}"_c17,
+    u8"D{(a, b)\u2208X1 | 1=2}"_c17
+  );
+  ExpectASTGeneration(
+    u8"D{(a,b,c) \u2208 X1|1=2}"_c17,
+    u8"D{(a, b, c)\u2208X1 | 1=2}"_c17
+  );
+  ExpectASTGeneration(
+    u8"D{(a,(b,c)) \u2208 X1|1=2}"_c17
+    , u8"D{(a, (b, c))\u2208X1 | 1=2}"_c17
+  );
+  ExpectASTGeneration(
+    u8"D{((a,b),c) \u2208 X1|1=2}"_c17,
+    u8"D{((a, b), c)\u2208X1 | 1=2}"_c17
+  );
+  ExpectASTGeneration(
+    "R{a:=X1 | 1=1| a \\ a}",
+    "R{a:=X1 | 1=1 | a\\a}"
+  );
+  ExpectASTGeneration(
+    u8"I{ (a,b) | b:\u2208X1; a:= b; 1=1}"_c17,
+    u8"I{(a, b) | b:\u2208X1; a:=b; 1=1}"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, FromASTTypedOperators) {
-  ExpectASTGeneration("X1\\(X2\\X3)", "X1\\(X2\\X3)");
-  ExpectASTGeneration("(X1\\X2)\\X3", "X1\\X2\\X3");
-  ExpectASTGeneration("X1\\X2\\X3", "X1\\X2\\X3");
-  ExpectASTGeneration(u8"X1\u222AX2\u222AX3"_c17, u8"X1\u222AX2\u222AX3"_c17);
-  ExpectASTGeneration(u8"X1\u2229X2\u2229X3"_c17, u8"X1\u2229X2\u2229X3"_c17);
-  ExpectASTGeneration(u8"X1\u2206X2\u2206X3"_c17, u8"X1\u2206X2\u2206X3"_c17);
+  ExpectASTGeneration(
+    "X1\\(X2\\X3)",
+    "X1\\(X2\\X3)"
+  );
+  ExpectASTGeneration(
+    "(X1\\X2)\\X3",
+    "X1\\X2\\X3"
+  );
+  ExpectASTGeneration(
+    "X1\\X2\\X3",
+    "X1\\X2\\X3"
+  );
+  ExpectASTGeneration(
+    u8"X1\u222AX2\u222AX3"_c17,
+    u8"X1\u222AX2\u222AX3"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1\u2229X2\u2229X3"_c17,
+    u8"X1\u2229X2\u2229X3"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1\u2206X2\u2206X3"_c17,
+    u8"X1\u2206X2\u2206X3"_c17
+  );
 
-  ExpectASTGeneration(u8"X1\\(X2\u222AX3)"_c17, u8"X1\\(X2\u222AX3)"_c17);
+  ExpectASTGeneration(
+    u8"X1\\(X2\u222AX3)"_c17,
+    u8"X1\\(X2\u222AX3)"_c17
+  );
 
-  ExpectASTGeneration(u8"X1\u00D7X2\u00D7X3"_c17, u8"X1\u00D7X2\u00D7X3"_c17);
-  ExpectASTGeneration(u8"(X1\u00D7X2)\u00D7X3"_c17, u8"(X1\u00D7X2)\u00D7X3"_c17);
-  ExpectASTGeneration(u8"X1\u00D7(X2\u00D7X3)"_c17, u8"X1\u00D7(X2\u00D7X3)"_c17);
-  ExpectASTGeneration(u8"X1\u00D7Pr1( S1 )"_c17, u8"X1\u00D7Pr1(S1)"_c17);
-  ExpectASTGeneration(u8"Pr1( S1 )\u00D7X1"_c17, u8"Pr1(S1)\u00D7X1"_c17);
-  ExpectASTGeneration(u8"{ S1 }\u00D7X1"_c17, u8"{S1}\u00D7X1"_c17);
-  ExpectASTGeneration(u8"X1\u00D7{ S1 }"_c17, u8"X1\u00D7{S1}"_c17);
+  ExpectASTGeneration(
+    u8"X1\u00D7X2\u00D7X3"_c17,
+    u8"X1\u00D7X2\u00D7X3"_c17
+  );
+  ExpectASTGeneration(
+    u8"(X1\u00D7X2)\u00D7X3"_c17,
+    u8"(X1\u00D7X2)\u00D7X3"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1\u00D7(X2\u00D7X3)"_c17,
+    u8"X1\u00D7(X2\u00D7X3)"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1\u00D7Pr1( S1 )"_c17,
+    u8"X1\u00D7Pr1(S1)"_c17
+  );
+  ExpectASTGeneration(
+    u8"Pr1( S1 )\u00D7X1"_c17,
+    u8"Pr1(S1)\u00D7X1"_c17
+  );
+  ExpectASTGeneration(
+    u8"{ S1 }\u00D7X1"_c17,
+    u8"{S1}\u00D7X1"_c17
+  );
+  ExpectASTGeneration(
+    u8"X1\u00D7{ S1 }"_c17,
+    u8"X1\u00D7{S1}"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, CreateCall) {
@@ -234,12 +475,22 @@ TEST_F(UTRSGenerator, FunctionFromExpression) {
 
   EXPECT_EQ(gen.FunctionFromExpr({}, ""), "");
   EXPECT_EQ(gen.FunctionFromExpr({ "S1" }, ""), "");
-  EXPECT_EQ(gen.FunctionFromExpr({ "S1" }, "X1\\X1"), u8"[arg1\u2208\u212C(X1)] X1\\X1"_c17);
-  EXPECT_EQ(gen.FunctionFromExpr({ "S1" }, "S1\\X1"), u8"[arg1\u2208\u212C(X1)] arg1\\X1"_c17);
-  EXPECT_EQ(gen.FunctionFromExpr({ "S1", "X1" }, "S1\\X1"), 
-            u8"[arg1\u2208\u212C(X1), arg2\u2208\u212C(X1)] arg1\\arg2"_c17);
-  EXPECT_EQ(gen.FunctionFromExpr({ "S1" }, u8"{arg1 \u2208 S1 | 1=1}"_c17),
-            u8"[arg2\u2208\u212C(X1)] {arg1 \u2208 arg2 | 1=1}"_c17);
+  EXPECT_EQ(
+    gen.FunctionFromExpr({ "S1" }, "X1\\X1"),
+    u8"[arg1\u2208\u212C(X1)] X1\\X1"_c17
+  );
+  EXPECT_EQ(
+    gen.FunctionFromExpr({ "S1" }, "S1\\X1"),
+    u8"[arg1\u2208\u212C(X1)] arg1\\X1"_c17
+  );
+  EXPECT_EQ(
+    gen.FunctionFromExpr({ "S1", "X1" }, "S1\\X1"), 
+    u8"[arg1\u2208\u212C(X1), arg2\u2208\u212C(X1)] arg1\\arg2"_c17
+  );
+  EXPECT_EQ(
+    gen.FunctionFromExpr({ "S1" }, u8"{arg1 \u2208 S1 | 1=1}"_c17),
+    u8"[arg2\u2208\u212C(X1)] {arg1 \u2208 arg2 | 1=1}"_c17
+  );
 }
 
 TEST_F(UTRSGenerator, GenerateStructure) {
@@ -259,20 +510,30 @@ TEST_F(UTRSGenerator, GenerateStructure) {
 TEST_F(UTRSGenerator, Ascii2RS) {
   using ccl::rslang::ConvertTo;
 
-  EXPECT_EQ(ConvertTo(R"(S1 \in B(X1))", Syntax::MATH), u8"S1\u2208\u212C(X1)"_c17);
-  EXPECT_EQ(ConvertTo("B(Y*(X1*X2)*BB(X3))", Syntax::MATH),
-            u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17);
+  EXPECT_EQ(
+    ConvertTo(R"(S1 \in B(X1))", Syntax::MATH),
+    u8"S1\u2208\u212C(X1)"_c17
+  );
+  EXPECT_EQ(
+    ConvertTo("B(Y*(X1*X2)*BB(X3))", Syntax::MATH),
+    u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17
+  );
 
   EXPECT_EQ(ConvertTo("  X1  ", Syntax::MATH), "X1");
   EXPECT_EQ(ConvertTo("a,?b", Syntax::MATH), "a,?b");
 }
 
 TEST_F(UTRSGenerator, RS2Ascii) {
-  EXPECT_EQ(ConvertTo(u8"S1\u2208\u212C(X1)"_c17, Syntax::ASCII), R"(S1 \in B(X1))");
-  EXPECT_EQ(ConvertTo(u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17, Syntax::ASCII),
-            R"(B(Y*(X1*X2)*BB(X3)))");
+  EXPECT_EQ(
+    ConvertTo(u8"S1\u2208\u212C(X1)"_c17, Syntax::ASCII),
+    R"(S1 \in B(X1))"
+  );
+  EXPECT_EQ(
+    ConvertTo(u8"\u212C(Y\u00D7(X1\u00D7X2)\u00D7\u212C\u212C(X3))"_c17, Syntax::ASCII),
+    R"(B(Y*(X1*X2)*BB(X3)))"
+  );
 
-  EXPECT_EQ(ccl::rslang::ConvertTo("  X1  ", Syntax::ASCII), R"(X1)");
-  EXPECT_EQ(ccl::rslang::ConvertTo("\xE2\x88\x85", Syntax::ASCII), R"({})");
-  EXPECT_EQ(ccl::rslang::ConvertTo("a,?b", Syntax::ASCII), R"(a,?b)");
+  EXPECT_EQ(ConvertTo("  X1  ", Syntax::ASCII), R"(X1)");
+  EXPECT_EQ(ConvertTo("\xE2\x88\x85", Syntax::ASCII), R"({})");
+  EXPECT_EQ(ConvertTo("a,?b", Syntax::ASCII), R"(a,?b)");
 }
\ No newline at end of file
diff --git a/ccl/rslang/test/src/testRSParser.cpp b/ccl/rslang/test/src/testRSParser.cpp
index 153ffff..af36595 100644
--- a/ccl/rslang/test/src/testRSParser.cpp
+++ b/ccl/rslang/test/src/testRSParser.cpp
@@ -5,6 +5,7 @@
 #include "ccl/rslang/RSParser.h"
 #include "ccl/rslang/AsciiLexer.h"
 #include "ccl/rslang/ErrorLogger.h"
+#include "ccl/rslang/Literals.h"
 
 using ccl::operator""_c17;
 
@@ -100,14 +101,22 @@ TEST_F(UTRSParser, GlobalDeclAST) {
   ExpectAST(R"(S1 \deftype B(X1))", u8"[::=[S1][\u212C[X1]]]"_c17);
   ExpectAST(R"(D1 \defexpr X1 \setminus X2)", u8"[:==[D1][\\[X1][X2]]]"_c17);
   ExpectAST(R"(A1 \defexpr 1 \eq 1)", u8"[:==[A1][=[1][1]]]"_c17);
-  ExpectAST(R"(F1 \defexpr [a \in X1] X1 \setminus a)", 
-            u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]]][\\[X1][a]]]]"_c17);
-  ExpectAST(R"(P1 \defexpr [a \in X1] 1 \eq 1)", 
-            u8"[:==[P1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]]][=[1][1]]]]"_c17);
-  ExpectAST(R"(F1 \defexpr [a \in X1, b \in X1] {b,a})",
-            u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][SET[b][a]]]]"_c17);
-  ExpectAST(R"(F1 \defexpr [a \in R1, b \in B(X1*R1)] {a} \setminus Pr2(b))",
-            u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][R1]][ARG[b][\u212C[\u00D7[X1][R1]]]]][\\[SET[a]][Pr2[b]]]]]"_c17);
+  ExpectAST(
+    R"(F1 \defexpr [a \in X1] X1 \setminus a)",
+    u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]]][\\[X1][a]]]]"_c17
+  );
+  ExpectAST(
+    R"(P1 \defexpr [a \in X1] 1 \eq 1)",
+    u8"[:==[P1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]]][=[1][1]]]]"_c17
+  );
+  ExpectAST(
+    R"(F1 \defexpr [a \in X1, b \in X1] {b,a})",
+    u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][SET[b][a]]]]"_c17
+  );
+  ExpectAST(
+    R"(F1 \defexpr [a \in R1, b \in B(X1*R1)] {a} \setminus Pr2(b))",
+    u8"[:==[F1][FUNCTION_DEFINITION[ARGS[ARG[a][R1]][ARG[b][\u212C[\u00D7[X1][R1]]]]][\\[SET[a]][Pr2[b]]]]]"_c17
+  );
 }
 
 TEST_F(UTRSParser, GlobalDeclErrors) {
@@ -138,6 +147,7 @@ TEST_F(UTRSParser, LogicPredicatesCorrect) {
 }
 
 TEST_F(UTRSParser, LogicPredicatesAST) {
+  ExpectAST(R"(a \in X1)", u8"[\u2208[a][X1]]"_c17);
   ExpectAST(R"(1 \eq 2)", u8"[=[1][2]]"_c17);
   ExpectAST(R"(1 \ls X1)", u8"[<[1][X1]]"_c17);
   ExpectAST(R"(1 \gr 2)", u8"[>[1][2]]"_c17);
@@ -150,6 +160,8 @@ TEST_F(UTRSParser, LogicPredicatesErrors) {
   ExpectError(R"(1 \eq 1 \eq 1)", ParseEID::syntax, 8);
   ExpectError(R"(1 \gr 1 \eq 1)", ParseEID::syntax, 8);
   ExpectError(R"(P1[])", ParseEID::syntax, 3);
+  ExpectError(R"(a \assign X1)", ParseEID::invalidImperative, 0);
+  ExpectError(R"(a \from X1)", ParseEID::invalidImperative, 0);
 }
 
 TEST_F(UTRSParser, LogicOperatorsCorrect) {
@@ -170,16 +182,39 @@ TEST_F(UTRSParser, LogicOperatorsCorrect) {
 TEST_F(UTRSParser, LogicOperatorsAST) {
   ExpectAST(R"(\neg 1 \eq 2)", u8"[\u00AC[=[1][2]]]"_c17);
 
-  ExpectAST(R"(1 \eq 1 \and 2 \eq 2 \and 3 \eq 3)", "[&[&[=[1][1]][=[2][2]]][=[3][3]]]");
-  ExpectAST(R"(1 \eq 1 \or 2 \eq 2 \or 3 \eq 3)", u8"[\u2228[\u2228[=[1][1]][=[2][2]]][=[3][3]]]"_c17);
-  ExpectAST(R"(1 \eq 1 \impl 2 \eq 2 \impl 3 \eq 3)", u8"[\u21D2[\u21D2[=[1][1]][=[2][2]]][=[3][3]]]"_c17);
-  ExpectAST(R"(1 \eq 1 \equiv 2 \eq 2 \equiv 3 \eq 3)", u8"[\u21D4[\u21D4[=[1][1]][=[2][2]]][=[3][3]]]"_c17);
+  ExpectAST(
+    R"(1 \eq 1 \and 2 \eq 2 \and 3 \eq 3)",
+    "[&[&[=[1][1]][=[2][2]]][=[3][3]]]"
+  );
+  ExpectAST(
+    R"(1 \eq 1 \or 2 \eq 2 \or 3 \eq 3)",
+    u8"[\u2228[\u2228[=[1][1]][=[2][2]]][=[3][3]]]"_c17
+  );
+  ExpectAST(
+    R"(1 \eq 1 \impl 2 \eq 2 \impl 3 \eq 3)",
+    u8"[\u21D2[\u21D2[=[1][1]][=[2][2]]][=[3][3]]]"_c17
+  );
+  ExpectAST(
+    R"(1 \eq 1 \equiv 2 \eq 2 \equiv 3 \eq 3)",
+    u8"[\u21D4[\u21D4[=[1][1]][=[2][2]]][=[3][3]]]"_c17
+  );
 
-  ExpectAST(R"((1 \eq 1 \and 2 \eq 2) \and 3 \eq 3)", "[&[&[=[1][1]][=[2][2]]][=[3][3]]]");
-  ExpectAST(R"(1 \eq 1 \and (2 \eq 2 \and 3 \eq 3))", "[&[=[1][1]][&[=[2][2]][=[3][3]]]]");
-  ExpectAST(R"(1 \eq 1 \or 2 \eq 2 \and 3 \eq 3)", u8"[\u2228[=[1][1]][&[=[2][2]][=[3][3]]]]"_c17);
-  ExpectAST(R"(1 \eq 1 \and 2 \eq 2 \or 3 \eq 3 \impl 4 \eq 4 \equiv 5 \eq 5)",
-            u8"[\u21D4[\u21D2[\u2228[&[=[1][1]][=[2][2]]][=[3][3]]][=[4][4]]][=[5][5]]]"_c17);
+  ExpectAST(
+    R"((1 \eq 1 \and 2 \eq 2) \and 3 \eq 3)",
+    "[&[&[=[1][1]][=[2][2]]][=[3][3]]]"
+  );
+  ExpectAST(
+    R"(1 \eq 1 \and (2 \eq 2 \and 3 \eq 3))",
+    "[&[=[1][1]][&[=[2][2]][=[3][3]]]]"
+  );
+  ExpectAST(
+    R"(1 \eq 1 \or 2 \eq 2 \and 3 \eq 3)",
+    u8"[\u2228[=[1][1]][&[=[2][2]][=[3][3]]]]"_c17
+  );
+  ExpectAST(
+    R"(1 \eq 1 \and 2 \eq 2 \or 3 \eq 3 \impl 4 \eq 4 \equiv 5 \eq 5)",
+    u8"[\u21D4[\u21D2[\u2228[&[=[1][1]][=[2][2]]][=[3][3]]][=[4][4]]][=[5][5]]]"_c17
+  );
 }
 
 TEST_F(UTRSParser, LogicOperatorsErrors) {
@@ -204,20 +239,35 @@ TEST_F(UTRSParser, LogicQuantifiedCorrect) {
 
   ExpectNoWarnings(R"(\A a \in X1 \A b \in X1 1 \eq 1)");
   ExpectNoWarnings(R"(\A a,b,c \in X1 1 \eq 1)");
+  ExpectNoWarnings(R"(\A a,b,c,d \in X1 1 \eq 1)");
   ExpectNoWarnings(R"(\A (a,b,c) \in X1 1 \eq 1)");
+  ExpectNoWarnings(R"(\A (a,(b,d),c) \in X1 1 \eq 1)");
 }
 
 TEST_F(UTRSParser, LogicQuantifiedAST) {
-  ExpectAST(R"(\A a \in X1 1 \eq 2)", u8"[\u2200[a][X1][=[1][2]]]"_c17);
-  ExpectAST(R"(\A a,b \in X1 1 \eq 2)", u8"[\u2200[ENUM_DECLARATION[a][b]][X1][=[1][2]]]"_c17);
-  ExpectAST(R"(\A a \in X1 1 \eq 2 \and 3 \eq 4)", u8"[&[\u2200[a][X1][=[1][2]]][=[3][4]]]"_c17);
-  ExpectAST(R"(\A a \in X1 (1 \eq 2 \and 3 \eq 4))", u8"[\u2200[a][X1][&[=[1][2]][=[3][4]]]]"_c17);
+  ExpectAST(
+    R"(\A a \in X1 1 \eq 2)",
+    u8"[\u2200[a][X1][=[1][2]]]"_c17
+  );
+  ExpectAST(
+    R"(\A a,b \in X1 1 \eq 2)",
+    u8"[\u2200[ENUM_DECLARATION[a][b]][X1][=[1][2]]]"_c17
+  );
+  ExpectAST(
+    R"(\A a \in X1 1 \eq 2 \and 3 \eq 4)",
+    u8"[&[\u2200[a][X1][=[1][2]]][=[3][4]]]"_c17
+  );
+  ExpectAST(
+    R"(\A a \in X1 (1 \eq 2 \and 3 \eq 4))",
+    u8"[\u2200[a][X1][&[=[1][2]][=[3][4]]]]"_c17
+  );
 }
 
 TEST_F(UTRSParser, LogicQuantifiedErrors) {
   ExpectError(R"(\A a \in X1, \A b \in X1 1 \eq 1)", ParseEID::invalidQuantifier, 11);
   ExpectError(R"(\A ()", ParseEID::invalidQuantifier, 4);
   ExpectError(R"(\A (a,X1) \in X1 1 \eq 1)", ParseEID::expectedLocal, 6);
+  ExpectError(R"(\A ((a,X1),b) \in X1 1 \eq 1)", ParseEID::expectedLocal, 7);
   ExpectError(R"(\A a \notsubset X1 1 \eq 1)", ParseEID::invalidQuantifier, 5);
   ExpectError(R"(\A a \notin X1 1 \eq 1)", ParseEID::invalidQuantifier, 5);
   ExpectError(R"(\A a \subset X1 1 \eq 2)", ParseEID::invalidQuantifier, 5);
@@ -249,7 +299,7 @@ TEST_F(UTRSParser, Identifiers) {
   ExpectNoWarnings(R"(hello_world)");
 }
 
-TEST_F(UTRSParser, TermOperatorsCorrect) {
+TEST_F(UTRSParser, SetexprOperatorsCorrect) {
   TestAllBinaryCombos(R"( \plus )");
   TestAllBinaryCombos(R"( \minus )");
   TestAllBinaryCombos(R"( \multiply )");
@@ -270,7 +320,7 @@ TEST_F(UTRSParser, TermOperatorsCorrect) {
   TestAllBinaryCombos(R"( * )");
 }
 
-TEST_F(UTRSParser, TermOperatorsAST) {
+TEST_F(UTRSParser, SetexprOperatorsAST) {
   ExpectAST(R"(1 \plus 2 \plus 3)", "[+[+[1][2]][3]]");
   ExpectAST(R"((1 \plus 2) \plus 3)", "[+[+[1][2]][3]]");
   ExpectAST(R"(1 \plus (2 \plus 3))", "[+[1][+[2][3]]]");
@@ -284,11 +334,13 @@ TEST_F(UTRSParser, TermOperatorsAST) {
   ExpectAST(R"(a \setminus b \setminus c)", "[\\[\\[a][b]][c]]");
   ExpectAST(R"((a \setminus b) \setminus c)", "[\\[\\[a][b]][c]]");
   ExpectAST(R"(a \setminus (b \setminus c))", "[\\[a][\\[b][c]]]");
-  ExpectAST(R"(((a \union b) \intersect (c \setminus d)) \symmdiff (e * f))",
-            u8"[\u2206[\u2229[\u222A[a][b]][\\[c][d]]][\u00D7[e][f]]]"_c17);
+  ExpectAST(
+    R"(((a \union b) \intersect (c \setminus d)) \symmdiff (e * f))",
+    u8"[\u2206[\u2229[\u222A[a][b]][\\[c][d]]][\u00D7[e][f]]]"_c17
+  );
 }
 
-TEST_F(UTRSParser, TermOperatorsErrors) {
+TEST_F(UTRSParser, SetexprOperatorsErrors) {
   ExpectError(R"(1 \plus  \plus )", ParseEID::syntax, 9);
   ExpectError(R"(1 \minus  \minus )", ParseEID::syntax, 10);
 
@@ -301,7 +353,7 @@ TEST_F(UTRSParser, TermOperatorsErrors) {
   ExpectError(R"(X1 \setminus (1))", ParseEID::syntax, 15);
 }
 
-TEST_F(UTRSParser, TermTextOperationsCorrect) {
+TEST_F(UTRSParser, SetexprTextOperationsCorrect) {
   ExpectNoWarnings(R"(card(X1))");
   ExpectNoWarnings(R"(card(1))");
   ExpectNoWarnings(R"(card(a))");
@@ -317,18 +369,18 @@ TEST_F(UTRSParser, TermTextOperationsCorrect) {
   ExpectNoWarnings(R"(red(a))");
 }
 
-TEST_F(UTRSParser, TermTextOperationsAST) {
+TEST_F(UTRSParser, SetexprTextOperationsAST) {
   ExpectAST(R"(card(X1))", u8"[card[X1]]"_c17);
   ExpectAST(R"(Pr2(a))", u8"[Pr2[a]]"_c17);
   ExpectAST(R"(Fi1,2[b](a))", u8"[Fi1,2[b][a]]"_c17);
 }
 
-TEST_F(UTRSParser, TermTextOperationsErrors) {
+TEST_F(UTRSParser, SetexprTextOperationsErrors) {
   ExpectError(R"(Pr1,b(a))", ParseEID::syntax, 3);
   ExpectError(R"(Fi1,b[c](a))", ParseEID::syntax, 3);
 }
 
-TEST_F(UTRSParser, TermConstructorsCorrect) {
+TEST_F(UTRSParser, SetexprConstructorsCorrect) {
   ExpectNoWarnings(R"(B(a))");
   ExpectNoWarnings(R"(B(a*b*(c*d)))");
   ExpectNoWarnings(R"(BB(a))");
@@ -352,9 +404,10 @@ TEST_F(UTRSParser, TermConstructorsCorrect) {
   ExpectNoWarnings(R"(I{(b, a) | a \from X1; b \assign a})");
   ExpectNoWarnings(R"(I{ red(b) | a \from X1; b \assign a})");
   ExpectNoWarnings(R"(I{(a, b) | a \from X1; b \assign a; (a,b) \in S1})");
+  ExpectNoWarnings(R"(I{(a, d) | (a,c) \from X1*X1; (b,d) \assign (a,c); (a,b) \in S1})");
 }
 
-TEST_F(UTRSParser, TermConstructorsAST) {
+TEST_F(UTRSParser, SetexprConstructorsAST) {
   ExpectAST(R"(B(a))", u8"[\u212C[a]]"_c17);
 
   ExpectAST(R"((a,b,c))", u8"[TUPLE[a][b][c]]"_c17);
@@ -362,25 +415,43 @@ TEST_F(UTRSParser, TermConstructorsAST) {
   ExpectAST(R"({{a, b}, {c, d}})", u8"[SET[SET[a][b]][SET[c][d]]]"_c17);
   ExpectAST(R"({a})", u8"[SET[a]]"_c17);
 
-  ExpectAST(R"(D{a \in X1 | 1 \eq 2})",
-            u8"[DECLARATIVE[a][X1][=[1][2]]]"_c17);
-  ExpectAST(R"(D{(a,b) \in X1 | 1 \eq 2})",
-            u8"[DECLARATIVE[TUPLE_DECLARATION[a][b]][X1][=[1][2]]]"_c17);
+  ExpectAST(
+    R"(D{a \in X1 | 1 \eq 2})",
+    u8"[DECLARATIVE[a][X1][=[1][2]]]"_c17
+  );
+  ExpectAST(
+    R"(D{(a,b) \in X1 | 1 \eq 2})",
+    u8"[DECLARATIVE[TUPLE_DECLARATION[a][b]][X1][=[1][2]]]"_c17
+  );
 
-  ExpectAST(R"(R{a \assign S1 | card(a) \ls 10 | a \setminus a})",
-            u8"[REC_FULL[a][S1][<[card[a]][10]][\\[a][a]]]"_c17);
-  ExpectAST(R"(R{a \assign S1 | a \setminus a})",
-            u8"[REC_SHORT[a][S1][\\[a][a]]]"_c17);
-  ExpectAST(R"(R{(a,b) \assign S1 | (a \setminus a, b)})",
-            u8"[REC_SHORT[TUPLE_DECLARATION[a][b]][S1][TUPLE[\\[a][a]][b]]]"_c17);
+  ExpectAST(
+    R"(R{a \assign S1 | card(a) \ls 10 | a \setminus a})",
+    u8"[REC_FULL[a][S1][<[card[a]][10]][\\[a][a]]]"_c17
+  );
+  ExpectAST(
+    R"(R{a \assign S1 | a \setminus a})",
+    u8"[REC_SHORT[a][S1][\\[a][a]]]"_c17
+  );
+  ExpectAST(
+    R"(R{(a,b) \assign S1 | (a \setminus a, b)})",
+    u8"[REC_SHORT[TUPLE_DECLARATION[a][b]][S1][TUPLE[\\[a][a]][b]]]"_c17
+  );
 
-  ExpectAST(R"(I{(a, b) | a \from X1; b \assign a})",
-            u8"[IMPERATIVE[TUPLE[a][b]][IDECLARE[a][X1]][IASSIGN[b][a]]]"_c17);
-  ExpectAST(R"(I{(a, b) | a \from X1; b \assign a; (a,b) \in S1})",
-            u8"[IMPERATIVE[TUPLE[a][b]][IDECLARE[a][X1]][IASSIGN[b][a]][ICHECK[\u2208[TUPLE[a][b]][S1]]]]"_c17);
+  ExpectAST(
+    R"(I{(a, b) | a \from X1; b \assign a})",
+    u8"[IMPERATIVE[TUPLE[a][b]][:\u2208[a][X1]][:=[b][a]]]"_c17
+  );
+  ExpectAST(
+    R"(I{(a, b) | a \from X1; b \assign a; (a,b) \in S1})",
+    u8"[IMPERATIVE[TUPLE[a][b]][:\u2208[a][X1]][:=[b][a]][\u2208[TUPLE[a][b]][S1]]]"_c17
+  );
+  ExpectAST(
+    R"(I{d | (a,b) \from X1; (c,(d,e)) \assign a; (c,e) \in S1})",
+    u8"[IMPERATIVE[d][:\u2208[TUPLE_DECLARATION[a][b]][X1]][:=[TUPLE_DECLARATION[c][TUPLE_DECLARATION[d][e]]][a]][\u2208[TUPLE[c][e]][S1]]]"_c17
+  );
 }
 
-TEST_F(UTRSParser, TermConstructorsErrors) {
+TEST_F(UTRSParser, SetexprConstructorsErrors) {
   ExpectError(R"({(a;b) \in X1 | 1 \eq 1})", ParseEID::syntax, 3);
 
   ExpectError(R"(D{a \in X1 | 1 \eq 1 a)", ParseEID::missingCurlyBrace, 21);
@@ -408,8 +479,14 @@ TEST_F(UTRSParser, FunctionDefinitionCorrect) {
 }
 
 TEST_F(UTRSParser, FunctionDefinitionAST) {
-  ExpectAST(R"([a \in X1, b \in X1] a \eq b)", u8"[FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][=[a][b]]]"_c17);
-  ExpectAST(R"([a \in X1, b \in X1] a \setminus b)", u8"[FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][\\[a][b]]]"_c17);
+  ExpectAST(
+    R"([a \in X1, b \in X1] a \eq b)",
+    u8"[FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][=[a][b]]]"_c17
+  );
+  ExpectAST(
+    R"([a \in X1, b \in X1] a \setminus b)",
+    u8"[FUNCTION_DEFINITION[ARGS[ARG[a][X1]][ARG[b][X1]]][\\[a][b]]]"_c17
+  );
 }
 
 TEST_F(UTRSParser, FunctionDefinitionErrors) {
diff --git a/ccl/rslang/test/src/testRSToken.cpp b/ccl/rslang/test/src/testRSToken.cpp
index ef40891..ebad277 100644
--- a/ccl/rslang/test/src/testRSToken.cpp
+++ b/ccl/rslang/test/src/testRSToken.cpp
@@ -129,16 +129,43 @@ TEST_F(UTRSToken, TokenToString) {
 TEST_F(UTRSToken, TokenToStringUnicode) {
   using ccl::operator""_c17;
 
-  EXPECT_EQ("p1", Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03C01"_c17 }).ToString(Syntax::ASCII));
-  EXPECT_EQ("aw", Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03B1\u03C9"_c17 }).ToString(Syntax::ASCII));
-  EXPECT_EQ("qu?u?p", Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03F0"_c17 }).ToString(Syntax::ASCII));
+  EXPECT_EQ(
+    Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03C01"_c17 }).ToString(Syntax::ASCII),
+    "p1"
+  );
+  EXPECT_EQ(
+    Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03B1\u03C9"_c17 }).ToString(Syntax::ASCII),
+    "aw"
+  );
+  EXPECT_EQ(
+    Token(TokenID::ID_LOCAL, StrRange{}, TokenData{ u8"\u03F0"_c17 }).ToString(Syntax::ASCII),
+    "qu?u?p"
+  );
 }
 
 TEST_F(UTRSToken, CompareOperations) {
-  EXPECT_EQ(Token::CompareOperations(TokenID::INTERRUPT, TokenID::INTERRUPT), Comparison::INCOMPARABLE);
-  EXPECT_EQ(Token::CompareOperations(TokenID::ID_LOCAL, TokenID::ID_LOCAL), Comparison::INCOMPARABLE);
-  EXPECT_EQ(Token::CompareOperations(TokenID::ID_LOCAL, TokenID::PLUS), Comparison::INCOMPARABLE);
-  EXPECT_EQ(Token::CompareOperations(TokenID::PLUS, TokenID::MINUS), Comparison::EQUAL);
-  EXPECT_EQ(Token::CompareOperations(TokenID::MULTIPLY, TokenID::MINUS), Comparison::GREATER);
-  EXPECT_EQ(Token::CompareOperations(TokenID::MINUS, TokenID::MULTIPLY), Comparison::LESS);
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::INTERRUPT, TokenID::INTERRUPT),
+    Comparison::INCOMPARABLE
+  );
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::ID_LOCAL, TokenID::ID_LOCAL),
+    Comparison::INCOMPARABLE
+  );
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::ID_LOCAL, TokenID::PLUS),
+    Comparison::INCOMPARABLE
+  );
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::PLUS, TokenID::MINUS),
+    Comparison::EQUAL
+  );
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::MULTIPLY, TokenID::MINUS),
+    Comparison::GREATER
+  );
+  EXPECT_EQ(
+    Token::CompareOperations(TokenID::MINUS, TokenID::MULTIPLY),
+    Comparison::LESS
+  );
 }
\ No newline at end of file
diff --git a/ccl/rslang/test/src/testTypeAuditor.cpp b/ccl/rslang/test/src/testTypeAuditor.cpp
index 8a037aa..81b709d 100644
--- a/ccl/rslang/test/src/testTypeAuditor.cpp
+++ b/ccl/rslang/test/src/testTypeAuditor.cpp
@@ -254,6 +254,7 @@ TEST_F(UTTypeAuditor, ConstructorsCorrect) {
 
   ExpectTypification(R"(I{(a, b) | a \from X1; b \assign a})", "B(X1*X1)"_t);
   ExpectTypification(R"(I{(a, b) | a \from X1; b \assign a; 1 \eq 1})", "B(X1*X1)"_t);
+  ExpectTypification(R"(I{(a, c) | (a,c) \from X1*X1; (b,d) \assign (a,a); d \eq b})", "B(X1*X1)"_t);
 }
 
 TEST_F(UTTypeAuditor, ConstructorsErrors) {
@@ -276,6 +277,8 @@ TEST_F(UTTypeAuditor, ConstructorsErrors) {
 
   ExpectError(R"(I{(a, b) | a \from X1; b \assign {a}; a \noteq b})", SemanticEID::typesNotCompatible, 47);
   ExpectError(R"(I{(a, b) | a \from X1; g \in a \setminus X2; b \assign {a}})", SemanticEID::invalidTypeOperation, 29);
+  ExpectError(R"(I{(a, c) | a \from X1; (a,c) \assign (a,a)})", SemanticEID::localShadowing, 24);
+  ExpectError(R"(I{(a, c) | a \from X1; (a,c) \from X1*X1})", SemanticEID::localShadowing, 24);
 }
 
 TEST_F(UTTypeAuditor, TypedPredicatesCorrect) {