diff --git a/coco/xreate.ATG b/coco/xreate.ATG
index b50fb1b..66e8ad4 100644
--- a/coco/xreate.ATG
+++ b/coco/xreate.ATG
@@ -1,599 +1,600 @@
 //TODO add ListLiteral
 //TODO ExprTyped:  assign default(none) type
 
 #include "ast.h"
 #include "ExternLayer.h"
 #include "pass/adhocpass.h"
 #include <string>
 #include <stack>
 
 #define wprintf(format, ...) \
                 char __buffer[100];    \
                 wcstombs(__buffer, format, 100);   \
                 fprintf(stderr, __buffer, __VA_ARGS__)
                 
 using namespace xreate;
 using namespace std;
 
 COMPILER Xreate
 
  xreate::AST root;  // current program unit 
  
  struct {
      std::stack<xreate::CodeScope*> scopesOld;
     xreate::CodeScope* scope = nullptr;
  } context;
  
  void pushContextScope(CodeScope* scope){
     context.scopesOld.push(context.scope);
     context.scope = scope;
  }
  
  void popContextScope(){
         context.scope = context.scopesOld.top();
         context.scopesOld.pop();
  }
      
 int nextToken()
 {
   scanner->ResetPeek();
   return scanner->Peek()->kind;
 }
 
 bool checkParametersList()
 {
     return la->kind == _ident && nextToken() == _lparen;
 }
 
 bool checkInfix()
 {
   return la->kind == _ident && nextToken() == _ident;
 }
 
 bool checkIndex()
 {
   return la->kind == _ident && nextToken()  == _lbrack;
 }
 
 bool checkFuncDecl()
 {
   if (la->kind != _ident) return false;
   
   int token2 = nextToken();
   int token3 = scanner->Peek()->kind;
   
   return  token2  == _assign && (token3 == _function || token3 == _pre);
 }
 
 bool checkAssignment()
 {
   if (la->kind != _ident) return false;
   
   scanner->ResetPeek();
   int token2 = scanner->Peek()->kind;
   if (token2 == _lcurbrack) {
       scanner->Peek();
       int token3 = scanner->Peek()->kind;
       if (token3 != _rcurbrack) return false;
       
       int token4 = scanner->Peek()->kind;
       return token4 == _assign;
   }
   
   return  token2  == _assign;
 }
 
 void recognizeIdentifier(Expression& i){
     if (!context.scope->recognizeIdentifier(i)){       
         if (!root.recognizeVariantIdentifier(i)){
             root.postponeIdentifier(context.scope, i);
         }
     }
 }
 
 enum SwitchKind{SWITCH_NORMAL, SWITCH_META};
 
 CHARACTERS
   letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
   any = ANY - '"'.
   digit = "0123456789".
   cr  = '\r'.
   lf  = '\n'.
   tab = '\t'.
 
 TOKENS
   ident = (letter | '_') {letter | digit | '_'}.
-  number = digit {digit}.
+  number = (digit | '-' digit) {digit}.
   string = '"' { any } '"'.
   function = "function".
   pre =  "pre".  
   lparen = '('. 
   rparen = ')'.
   lbrack = '['.
   rbrack = ']'.
   lcurbrack = '{'.
   rcurbrack = '}'.
   equal = "==".
   assign = '='.
   implic = '-' '>'.
   colon = ':'.
   context = "context".
   tagcolon   = "::".
   lse = "<=".
   lss = "<".
   gte = ">=".
   gtr = ">".
   
   ne1 = "!=".
   ne2= "<>".
   
 
 COMMENTS FROM "/*" TO "*/" NESTED
 COMMENTS FROM "//" TO lf
 
 IGNORE cr + lf + tab
 
 PRODUCTIONS
 
 Xreate =    (. Function* function; .)
 {(  RuleDecl 
     | InterfaceData | Imprt | ContextSection 
     | IF(checkFuncDecl()) FDecl<function>  (. root.add(function); .)
     | TDecl 
 )}                                         (. root.recognizePostponedIdentifiers(); .)
 .
 
 Ident<std::wstring& name>
 = ident                                     (. name = t->val; .).
 
 VarIdent<Expression& e>
 = ident                                     (. e = Expression(Atom<Identifier_t>(t->val)); .)
   [ lcurbrack (                              
         ident                               (. SemErr(coco_string_create("var version as ident is not implemented yet")); .)
       | number                              (. Attachments::put<VariableVersion>(e, Atom<Number_t>(t->val).get()); .)
   ) rcurbrack ]  .
   
 
 FDecl<Function*& f> =       (. std::wstring fname; std::wstring argName; TypeAnnotation typIn; TypeAnnotation typOut; bool flagIsPrefunct = false; Expression binding; .)
 Ident<fname> assign 
 [pre            (. flagIsPrefunct = true; .)]
 function 		(. f = new Function(fname); f->isPrefunction = flagIsPrefunct; CodeScope* entry = f->getEntryScope(); .)
 
 ['(' Ident<argName> tagcolon ExprAnnotations<binding>  (. f->addBinding(Atom<Identifier_t>(argName), move(binding)); .)
 {',' Ident<argName> tagcolon ExprAnnotations<binding>  (. f->addBinding(Atom <Identifier_t>(argName), move(binding));.)
 } ')']
 
 [ tagcolon  
 ( IF(flagIsPrefunct) FnTag<f>
   |  Type<typOut>
 )
 {';' FnTag<f> }]
 BDecl<entry>    (. entry->getBody().bindType(move(typOut));.)
 .
 
 ContextSection<>=                       (. Expression context; Function* f; .)
 "case" "context" tagcolon MetaSimpExpr<context>  
 lcurbrack { FDecl<f>                    (. f->guardContext = context; root.add(f); .)
 } rcurbrack.
 
   /**
    *                          TYPES  
    * 
    */
 TypeTerm<TypePrimitive& typ> =                       (. std::wstring tid; .)
   ("string" (. typ = TypePrimitive::String;.)
   | "num"   (. typ = TypePrimitive::Num;.)
   | "int"   (. typ = TypePrimitive::Int;.)
   | "float" (. typ = TypePrimitive::Float;.)
   | "bool" (. typ = TypePrimitive::Bool; .)
   | "i8"    (. typ = TypePrimitive::I8; .)
   | "i32"   (. typ = TypePrimitive::I32; .)
+  | "i64"   (. typ = TypePrimitive::I64; .)
   ).
 
 Type<TypeAnnotation& typ> =  (. TypeAnnotation typ2; TypePrimitive typ3; std::wstring tid, field; .)
 ( 
   TList<typ>   
 | TStruct<typ>
 | TypeTerm<typ3> (. typ = typ3; .) 
 | IF (checkIndex()) Ident<tid> lbrack
       Ident<field>      (. typ = TypeAnnotation(TypeOperator::ACCESS, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
       {',' Ident<field> (.  typ.fields.push_back(Atom<Identifier_t>(field).get());  .)
       } rbrack
       
 | Ident<tid>            (. typ = TypeAnnotation(TypeOperator::CUSTOM, {}); typ.__valueCustom = Atom<Identifier_t>(tid).get(); .)
     ['(' Type<typ2>     (. typ.__operator = TypeOperator::CALL; typ.__operands.push_back(typ2); .)
     {',' Type<typ2>     (. typ.__operands.push_back(typ2); .)
     } ')']
 ) .
 
 TList<TypeAnnotation& typ> =      (.      TypeAnnotation ty; .)
     '[' Type<ty>                         (. typ = TypeAnnotation(TypeOperator::ARRAY, {ty}); .)
     {',' Type<ty>                        (. typ.__operator = TypeOperator::TUPLE; typ.__operands.push_back(ty); .)
     }']'
   .
   
 TStruct<TypeAnnotation& typ> = (. TypeAnnotation t; std::wstring field; .)
   lcurbrack
     Ident<field> tagcolon Type<t>       (. typ = TypeAnnotation(TypeOperator::STRUCT, {t}); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
     {',' Ident<field> tagcolon Type<t>} (. typ.__operands.push_back(t); typ.fields.push_back(Atom<Identifier_t>(field).get()); .)
   rcurbrack.
   
  TDecl =  (. std::wstring ttag; TypeAnnotation t, t1; std::wstring tname, arg; std::vector<Atom<Identifier_t>> args; .)
   Ident<tname> assign "type"
   (
     "alias" Type<t>             (. root.add(move(t), Atom<Identifier_t>(tname)); .)
     | "variant" lparen Ident<arg>  (. t = TypeAnnotation(TypeOperator::VARIANT, {}); args.push_back(Atom<Identifier_t>(arg)); .)
         {',' Ident<arg>         (. args.push_back(Atom<Identifier_t>(arg)); .)
         } rparen                (. t.addFields(move(args)); root.add(move(t), Atom<Identifier_t>(tname)); .)
     
     | Ident<ttag> 
       ['('  Ident<arg>        (. args.push_back(Atom<Identifier_t>(arg));   .)
       {',' Ident<arg>         (. args.push_back(Atom<Identifier_t>(arg));   .)
       } ')']
       Type<t>                   (. t.addBindings(move(args)); root.add(move(t), Atom<Identifier_t>(tname)); .)
   ) '.' 
   .
   
 ContextDecl<CodeScope * scope> =        (. Expression tag; .)
 context tagcolon 
 MetaSimpExpr<tag>                     (. scope->tags.push_back(tag); .)
 {';' MetaSimpExpr<tag>                (. scope->tags.push_back(tag); .)
 }.
 
 VDecl<CodeScope* f> =  (. std::wstring vname; Expression var, value;.)
     VarIdent<var> assign ExprTyped<value>      (. f->addDeclaration(move(var), move(value)); .)
 .
 
 //TODO forbid multiple body declaration (ExprTyped) 
 BDecl<CodeScope* scope> =  lcurbrack      (. Expression body; pushContextScope(scope);  .)
     {(IF(checkAssignment()) VDecl<scope> '.'
     | RuleContextDecl<scope>  
     | ContextDecl<scope>'.'
     | ExprTyped<body>                     (. scope->setBody(body); .)    
     )}                                    (. popContextScope(); .)      
     rcurbrack . 
 
 IfDecl<Expression& e> =     (. Expression cond; ManagedScpPtr blockTrue = root.add(new xreate::CodeScope(context.scope)); ManagedScpPtr blockFalse = root.add(new xreate::CodeScope(context.scope)); .)
 "if" '(' Expr<cond> ')'                         (. e = Expression(Operator::IF, {cond}); .)
 tagcolon ExprAnnotations<e> 
 BDecl<&*blockTrue> "else" BDecl<&*blockFalse>   (.  e.addBlock(blockTrue); e.addBlock(blockFalse); .)
 .
 
 LoopDecl<Expression& e> = 
   (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc, contextClass; Expression tagsEl;
     ManagedScpPtr block = root.add(new xreate::CodeScope(context.scope)); .)
    "loop"
    ("map" '(' Expr<eIn> implic Ident<varEl>     (. e = Expression(Operator::MAP, {eIn}); .)
     tagcolon ExprAnnotations<tagsEl> ')' tagcolon ExprAnnotations<e> BDecl<&*block>
       (.
          e.addBindings({Atom<Identifier_t>(varEl)});
          block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl)); 
          e.addBlock(block); 
       .)
 
   |"fold" 
     ("inf" '(' Expr<eAcc> implic Ident<varAcc> ')' 
         (.
                 e = Expression(Operator::FOLD_INF, {eAcc});
                 e.addBindings({Atom<Identifier_t>(varAcc)});
         .)        
      tagcolon ExprAnnotations<e> BDecl<&*block>
         (.
                 block->addBinding(Atom<Identifier_t>(varAcc), Expression());
                 e.addBlock(block); 
         .)
   
      | '(' Expr<eIn> implic Ident<varEl> tagcolon ExprAnnotations<tagsEl> ['|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc>')'
             (.
                 e = Expression(Operator::FOLD, {eIn, eAcc});
                 e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
             .)
         tagcolon ExprAnnotations<e> BDecl<&*block>
             (.  
                 
                 block->addBinding(Atom<Identifier_t>(varEl), move(tagsEl));
                 block->addBinding(Atom<Identifier_t>(varAcc), Expression());
                 e.addBlock(block); 
             .)
     )
   | "context" '(' string                          (. contextClass = t->val; .)
     ')' BDecl<&*block> 
         (. e = Expression(Operator::LOOP_CONTEXT, {Expression(Atom<String_t>(std::move(contextClass)))});
             e.addBlock(block);
          .)
 ).
    
 SwitchDecl<Expression& eSwitch, SwitchKind flagSwitchKind> = (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); Expression eCondition; Expression tag;.)
 ["switch" 
     (   "ad" "hoc" lparen Expr<eCondition> tagcolon MetaSimpExpr<tag> rparen (. eSwitch.op = Operator::SWITCH_ADHOC;
                                                                                 eSwitch.operands.push_back(eCondition); 
                                                                                 eSwitch.addTags({tag}); 
                                                                                 flagSwitchKind = SWITCH_META; .)    
         | lparen Expr<eCondition> rparen tagcolon  ExprAnnotations<eSwitch>  (. eSwitch.operands.push_back(eCondition);.)
     )
 ]
   CaseDecl<eSwitch, flagSwitchKind> {CaseDecl<eSwitch, flagSwitchKind>}
 .
   
 CaseDecl<Expression& outer, SwitchKind flagSwitchKind> = (. ManagedScpPtr scope = root.add(new xreate::CodeScope(context.scope)); Expression condition; .)
   "case" 
   ( IF(flagSwitchKind == SWITCH_META)
         lparen MetaSimpExpr<condition> rparen BDecl<&*scope>  (. Expression exprCase(Operator::CASE, {}); exprCase.addTags({condition}); exprCase.addBlock(scope); outer.addArg(move(exprCase));.)
         
     | "default" BDecl<&*scope>                    (. Expression exprCase(Operator::CASE_DEFAULT, {});       
                                                    exprCase.addBlock(scope); 
                                                    outer.operands.insert(++outer.operands.begin(), exprCase); .)
   
     | lparen CaseParams<&*scope> rparen         (. ManagedScpPtr scopeBody = root.add(new xreate::CodeScope(&*scope)); Expression exprCase(Operator::CASE, {}); .)
       BDecl<&*scopeBody>                                (. exprCase.addBlock(scope); exprCase.addBlock(scopeBody); outer.addArg(move(exprCase)); .)
  ).
 
 CaseParams<CodeScope* scope> =           (. Expression condition; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
  ExprTyped<condition>                  (. guard.addArg(Expression(condition)); .)
    {',' ExprTyped<condition>             (. guard.addArg(Expression(condition)); .)
    }                                     (. scope->setBody(guard); popContextScope(); .)
 .
 
 IntrinsicDecl<Expression& outer>=        (. std::wstring name; .)
 "intrinsic" Ident< name>                 (. outer = Expression(Operator::CALL_INTRINSIC, {}); outer.setValue(Atom<Identifier_t>(name)); .)
 lparen [CalleeParams<outer>] rparen .
   
                               /*============================ INTERFACES ===============================*/
 Imprt<> =                           
 "import" "raw" lparen string      (. root.__rawImports.push_back(Atom<String_t>(t->val).get()); .) 
 rparen .
 
 InterfaceData<> = "interface" '('
   (   "dfa" ')'  InterfaceDFA
     | "extern-c" ')' InterfaceExternC
     | "cfa" ')' InterfaceCFA
     | "adhoc" ')' InterfaceAdhoc
     
   ).                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            
 
 InterfaceAdhoc<> = 
     '{' { PrefunctionSchemeDecl }  '}'.
      
 PrefunctionSchemeDecl<> =         (. TypeAnnotation typReturn; std::wstring prefName; Expression exprCases; .)
     pre function Ident<prefName> tagcolon Type<typReturn>
     lcurbrack SwitchDecl<exprCases, SWITCH_META> rcurbrack
                                   (. Expression prefData(Operator::CALL, {Atom<Identifier_t>(prefName), exprCases}); 
                                      prefData.bindType(typReturn); 
                                      root.addInterfaceData(Adhoc, move(prefData));  
                                   .).    
 
 
 InterfaceExternC<>  =   (.xreate::ExternData data; .)
   '{' {IncludeExternDecl<data> | LibExternDecl<data> } '}'
       (. root.addExternData(move(data));  .)
 .
 
 LibExternDecl<xreate::ExternData& data> =       (. std::wstring pkgname, libname; .)
   Ident<libname> assign "library" tagcolon "pkgconfig" 
   '(' string            (. pkgname = t->val; .)
   ')' '.'               (. data.addLibrary(Atom<Identifier_t>(libname), Atom<String_t>(pkgname)); .)
 . 
 
 IncludeExternDecl<xreate::ExternData& data> =   (. Expression inc; .)
   "include" StructLiteral<inc> '.'              (. data.addIncludeDecl(move(inc)); .)
 .
   
 InterfaceDFA<> = '{' { InstructDecl } '}' .
 
 InstructDecl =                        (.Operator op; Expression tag; 
                                   Expression scheme; 
                                   std::vector<Expression>& tags = scheme.operands; 
                                   tags.push_back(Expression()); /* return value */ .)
 "operator" InstructAlias<op> tagcolon '('      (.scheme.setOp(op); .)
 [
   MetaSimpExpr<tag>             (. tags.push_back(tag); .)
   {
       ',' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }
 ] ')' [ implic MetaSimpExpr<tag>             (. tags[0] = tag; .) 
       ]                                      (. root.addDFAData(move(scheme)); .)
 '.'.
 
 InstructAlias<Operator& op> = 
 (
    "map"  (. op = Operator::MAP; .)
   | "list_range" (. op = Operator::LIST_RANGE; .)
   | "list"       (. op = Operator::LIST; .)
   | "fold"       (. op = Operator::FOLD; .)
   | "index"      (. op = Operator::INDEX; .) 
 ). 
 
 
 InterfaceCFA<> = '{' { InstructCFADecl } '}' .
 
 InstructCFADecl<> =                          (.Operator op; Expression tag; 
                                                 Expression scheme; 
                                                 std::vector<Expression>& tags = scheme.operands;  .)
 
 "operator" InstructAlias<op> tagcolon     (. scheme.setOp(op); .)
 [
   MetaSimpExpr<tag>             (. tags.push_back(tag); .)
   {
       ',' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }
 ] '.'                           (. root.addInterfaceData(CFA, move(scheme)); .).
     
                               /*============================ METAPROGRAMMING ===============================*/
 // TagsDecl<CodeScope* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
 // ':' { MetaSimpExpr<tag> (. /*f.addTag(std::move(tag), mod); */ .)
 // }.
 
 
 FnTag<Function* f> = (. Expression tag; TagModifier mod = TagModifier::NONE; .)
 MetaSimpExpr<tag>
 ['-' TagMod<mod>] (. f->addTag(std::move(tag), mod); .).
 
 TagMod<TagModifier& mod> = 
 (  "assert" (. mod = TagModifier::ASSERT; .)
  | "require" (. mod = TagModifier::REQUIRE; .)
 ).
  
 RuleDecl<> =
 "rule" tagcolon         		(. RuleArguments args; RuleGuards guards; DomainAnnotation typ; std::wstring arg; .)
 '(' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
 {',' Ident<arg> tagcolon Domain<typ>  	(. args.add(arg, typ); .)
 } ')'
 ["case" RGuard<guards> {',' RGuard<guards>}]
 '{' RBody<args, guards> '}' .    	
 
 /* - TODO use RGuard for guards-*/
 RuleContextDecl<CodeScope* scope> =     (.Expression eHead, eGuards, eBody; .)
 "rule" "context" tagcolon MetaSimpExpr<eHead>
 "case" lparen MetaSimpExpr<eGuards> rparen
 '{' MetaSimpExpr<eBody> '}'             (.scope->contextRules.push_back(Expression(Operator::CONTEXT_RULE, {eHead, eGuards, eBody})); .).
 
 Domain<DomainAnnotation& dom> = 
 (
   "function"  				(. dom = DomainAnnotation::FUNCTION; .)
   | "variable"    			(. dom = DomainAnnotation::VARIABLE; .)
 ).
 
 RGuard<RuleGuards& guards>=          (. Expression e; .)
 MetaExpr<e>                       (. guards.add(std::move(e)); .).
 
 MetaExpr<Expression& e>=            (.Operator op; Expression e2; .)
 MetaExpr2<e>
 [MetaOp<op> MetaExpr2<e2>           (. e = Expression(op, {e, e2}); .)
 ].
 
 MetaExpr2<Expression& e>=
 (
 '(' MetaExpr<e> ')'
 | MetaSimpExpr<e>
 ).
 
 MetaSimpExpr<Expression& e>=      (. std::wstring i1, infix; Expression e2; .)
 ( '-' MetaSimpExpr<e2>            (. e = Expression(Operator::NEG, {e2}); .)
 | IF(checkParametersList()) Ident<i1>   (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(i1))}); .)
 '(' [ MetaCalleeParams<e> ] ')'
 | IF(checkInfix()) Ident<i1> Ident<infix> MetaSimpExpr<e2>                                       
                                         (. e = Expression(Operator::CALL, {Expression(Atom<Identifier_t>(infix))});
                                            e.addArg(Expression(Atom<Identifier_t>(i1)));
                                            e.addArg(std::move(e2));
                                         .)
 | Ident<i1>                             (. e = Expression(Atom<Identifier_t>(i1)); .)
 ).
 
 MetaCalleeParams<Expression& e> = (. Expression e2; .)
   MetaSimpExpr<e2>	     	(. e.addArg(Expression(e2)); .)
   {',' MetaSimpExpr<e2>		(. e.addArg(Expression(e2)); .)
   }.
 
 RBody<const RuleArguments& args, const RuleGuards& guards> =
                                   (. Expression e; std::wstring msg; .)
  "warning" MetaExpr<e> ["message" string (. msg = t->val; .)
 ]                                 (. root.add(new RuleWarning(RuleArguments(args), RuleGuards(guards), std::move(e), Atom<String_t>(msg))); .)
  .
 
 MetaOp< Operator& op> =
  implic                          (. op = Operator::IMPL; .)
 .
 
         /*============================ Expressions ===============================*/
 ExprAnnotations<Expression& e> = (. TypeAnnotation typ; std::list<Expression> tags; Expression tag; e.tags.clear();.)
 Type<typ>                    (. e.bindType(move(typ)); .)
   {';' MetaSimpExpr<tag>     (. tags.push_back(tag); .)
   }                          (. e.addTags(tags); .)
 .
   
 ExprTyped<Expression&e> = Expr<e> [tagcolon ExprAnnotations<e>].
 
 Expr< Expression& e>         (. Operator op; Expression e2; .)
 = ExprArithmAdd<e>		 
   [ RelOp<op>
     ExprArithmAdd<e2>      (. e = Expression(op, {e, e2});  .)
   ].
 
 ExprArithmAdd< Expression& e>=      (. Operator op; Expression e2; .)
   ExprArithmMul< e>
   [ AddOp< op>
     ExprArithmAdd< e2>         (. e = Expression(op, {e, e2});.)
   ].
 
 ExprArithmMul< Expression& e>         (. Operator op; Expression e2; .)
 = ExprPostfix< e>
   [ MulOp< op>
     ExprArithmMul< e2>        (. e = Expression(op, {e, e2}); .)
   ].
 
 ExprPostfix<Expression& e> 
 = Term<e> 
   [lbrack                    (. e = Expression(Operator::INDEX, {e}); .)
     CalleeParams<e> rbrack   
   ].
 
 
 Term< Expression& e>       (. std::wstring name; e = Expression(); .)
 =                        
   (IF (checkParametersList()) Ident< name> 
                                     (. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); .)
   '(' [CalleeParams<e>] ')'
   | VarIdent<e>                     (. recognizeIdentifier(e); .)
   | ListLiteral<e>                  (. /* tuple */.)    
   | StructLiteral<e>                (. /* struct */.)
   | LoopDecl<e>
   | IfDecl<e>   
   | SwitchDecl<e, SWITCH_NORMAL>
   | AdhocDecl<e>
   | IntrinsicDecl<e>
   | "true"                          (. e = Expression(Atom<Number_t>(1)); e.bindType(TypePrimitive::Bool); .)
   | "false"                         (. e = Expression(Atom<Number_t>(0)); e.bindType(TypePrimitive::Bool); .)
   | number                          (. e = Expression(Atom<Number_t>(t->val)); .)
   | string                          (. e = Expression(Atom<String_t>(t->val)); .)
   | '-' Term<e>                     (. e = Expression(Operator::NEG, {e}); .)
   | '(' ExprTyped<e> ')'  
   ).
   
 StructLiteral<Expression& e> =                     (. std::wstring key; Expression val; std::list<Atom<Identifier_t>> keys; .)
   '{' Ident<key> '=' Expr<val>                    (. keys.push_back(Atom<Identifier_t>(key)); e = Expression(Operator::LIST_NAMED, {val}); .)
   {',' Ident<key> '=' Expr<val>                 (.e.addArg(Expression(val)); keys.push_back(Atom<Identifier_t>(key)); .)
   } '}'                                         (. e.addBindings(keys.begin(), keys.end()); .)
   .
   
 ListLiteral<Expression& e> =  (. Expression eFrom, eTo; .)
 '['                                                             
 [ Expr<eFrom>                                                   (. e.addArg(Expression(eFrom)); .)
 (".."  Expr<eTo>                                                (. e.addArg(Expression(eTo)); e.setOp(Operator::LIST_RANGE); .)
  |{',' Expr<eFrom>                                              (. e.addArg(Expression(eFrom)); .)
 }                                                               (. e.setOp(Operator::LIST); .) 
 ) ] ']'.
 
 AdhocDecl<Expression& e> = (. Expression command; .)
 "ad" "hoc" MetaSimpExpr<command>       (. AdhocExpression exprAdhoc; exprAdhoc.setCommand(command); e = exprAdhoc; .).
 
 CalleeParams<Expression& e> = (. Expression e2; .)
   ExprTyped<e2>		(. e.addArg(Expression(e2)); .)
   {',' ExprTyped<e2> 		(. e.addArg(Expression(e2)); .)
   }.
 
 AddOp< Operator& op>
 =                        (. op = Operator::ADD; .)
   ( '+'
   | '-'                  (. op = Operator::SUB; .)
   ).
 
 MulOp< Operator& op>
 =                        (. op = Operator::MUL; .)
   ( '*'
   | '/'                  (. op = Operator::DIV; .)
   ).
 
 RelOp< Operator& op>
 =                         (. op = Operator::EQU; .)
   ( equal
   | (ne1 | ne2)           (. op = Operator::NE; .)
   
   | lse                   (. op = Operator::LSE; .)
   | lss                   (. op = Operator::LSS; .)
   
   | gte                   (. op = Operator::GTE; .)
   | gtr                   (. op = Operator::GTR; .)
   
   ).
   
 END Xreate.
diff --git a/config/default.json b/config/default.json
index 9f1f85a..f928097 100644
--- a/config/default.json
+++ b/config/default.json
@@ -1,69 +1,69 @@
 {
     "containers": {
       "id": {
           "implementations": "impl_fulfill_cluster",
           "clusters": "var_cluster",
           "prototypes": "proto_cluster",
           "linkedlist": "linkedlist"
       }, 
       
       "impl": {
         "solid": "solid",
         "onthefly": "on_the_fly"
       }
     },
     
     "logging": {
       "id": "logging"
     },
     
     "function-entry": "entry",
     
     "clasp": {
       "bindings" : {
         "variable": "bind",
         "function": "bind_func",
         "scope": "bind_scope",
         "function_demand" : "bind_function_demand",
         "scope_decision": "bind_scope_decision"
       },
       
       "context" : {
         "decisions":{
             "dependent": "resolution_dependency"
         },
       }, 
       
       "nonevalue": "nonevalue",
       "ret": {
         "symbol": "retv",
         "tag": "ret"
       } 
     },
     
     "tests": { 
       "template": "default",
       
       "templates": {
         "default": "*-",
         
         "adhocs": "Adhoc.*",
         "effects": "Effects.*",
         "basic": "Attachments.*", 
         "ast": "AST.*",
         "cfa": "CFA.*",
         "dfa": "DFA.*",
-        "compilation": "Compilation.*",        
+        "compilation": "Compilation.functionEntry1*",        
         "diagnostic": "Diagnostic.*",
         "ExpressionSerializer": "ExpressionSerializer.*",
         "externc": "InterfaceExternC.*",
         "types": "Types.*-",       
         "vendorsAPI/clang": "ClangAPI.*",
         "vendorsAPI/xml2": "libxml2*",
-        "dsl": "Interpretation.*",
+        "dsl": "InterpretationExamples.*",
         "context": "Context.*",
         "containers": "Containers.*",
         "loops": "Loop.*"
       }
     }
 }
diff --git a/cpp/src/CMakeLists.txt b/cpp/src/CMakeLists.txt
index c42834a..78a19cc 100644
--- a/cpp/src/CMakeLists.txt
+++ b/cpp/src/CMakeLists.txt
@@ -1,218 +1,219 @@
 cmake_minimum_required(VERSION 2.8.11)
 project(xreate)
 cmake_policy(SET CMP0022 NEW)
 
 message("MODULES" ${CMAKE_MODULE_PATH})
 
 #       LLVM
 #======================
 FIND_PACKAGE (LLVM REQUIRED)
 set(LLVM_VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR})
 
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message("LLVM LIB PATH:" ${LLVM_LIBRARY_DIRS})
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 
 INCLUDE_DIRECTORIES(${LLVM_INCLUDE_DIRS})
 message(STATUS "INCLUDE DIR: ${LLVM_INCLUDE_DIRS}")
 
 add_definitions(${LLVM_DEFINITIONS})
 message("LLVM DEFS: " ${LLVM_DEFINITIONS})
 
 llvm_map_components_to_libnames(LLVM_LIBS core nativecodegen native executionengine mcjit support option)
 message("LLVM LIBS: " ${LLVM_LIBS})
 
 
 
 #       CLANG
 #======================
 set(CLANG_LIBS
 	clangCodeGen 
 	clangASTMatchers
 	clangQuery
 	clangTooling
 	clangFrontend
 	clangSerialization
 	clangDriver
 	clangParse
 	clangSema
 	clangAnalysis
 	clangAST
 	clangEdit
 	clangLex
 	clangBasic	
 )
 
 
 
 #       POTASSCO
 #======================
 set(POTASSCO_PATH "/opt/potassco/clingo" CACHE PATH "Path to potassco sources")
 set(POTASSCO_INCLUDE_PATH
     ${POTASSCO_PATH}/libgringo
     ${POTASSCO_PATH}/libclasp
     ${POTASSCO_PATH}/libclingo
     ${POTASSCO_PATH}/libprogram_opts
     ${POTASSCO_PATH}/liblp
 )
 INCLUDE_DIRECTORIES(${POTASSCO_INCLUDE_PATH})
 set(LIBCLASP_LIBS
     clingo
     clasp
     gringo
     program_opts
     reify
     lp
 )
 message("CLASP LIBS: " ${LIBCLASP_LIBS})
 
 
 
 #       OTHER DEPENDENCIES
 #===========================
 set(JEAYESON_INCLUDE_PATH
     ${CMAKE_HOME_DIRECTORY}/../vendors/jeayeson/include/
 )
 INCLUDE_DIRECTORIES(${JEAYESON_INCLUDE_PATH})
 
 
 
 #       COCO
 #===========================
 
 set(COCO_EXECUTABLE "" CACHE PATH "Path to coco executable")
 set(COCO_FRAMES_PATH "" CACHE PATH "Path to coco frames")
 
 set(COCO_GRAMMAR_PATH ${CMAKE_HOME_DIRECTORY}/../coco/)
 set(COCO_SOURCE_FILES 
         ${COCO_GRAMMAR_PATH}/Parser.cpp
         ${COCO_GRAMMAR_PATH}/Scanner.cpp)
 INCLUDE_DIRECTORIES(${COCO_GRAMMAR_PATH})
 
 add_custom_command(OUTPUT ${COCO_SOURCE_FILES}
     COMMAND ${COCO_GRAMMAR_PATH}/gen-grammar ${COCO_EXECUTABLE} ${COCO_FRAMES_PATH}
     WORKING_DIRECTORY ${COCO_GRAMMAR_PATH}
     MAIN_DEPENDENCY ${COCO_GRAMMAR_PATH}/xreate.ATG
 )
 message(STATUS "COCO GRAMMAR BUILD STATUS:" ${COCO_OUTPUT})
 
 
 
 #       XREATE
 #======================
 set(SOURCE_FILES
+    compilation/pointerarithmetic.cpp
     compilation/transformations.cpp
     compilation/transformersaturation.cpp
     pass/compilepass.cpp 
     pass/dfapass.cpp 
     analysis/dfagraph.cpp
     
     pass/versionspass.cpp
     compilation/targetinterpretation.cpp
         
     attachments.cpp
     ast.cpp
     
      ExternLayer.cpp 
 
      analysis/cfagraph.cpp
      
      analysis/aux.cpp
      compilation/containers.cpp
      compilation/advanced.cpp
 
      clasplayer.cpp
      compilation/latecontextcompiler2.cpp
      query/context.cpp
      
      llvmlayer.cpp 
      utils.cpp
      passmanager-bare.cpp
      passmanager-full.cpp
      pass/abstractpass.cpp 
      
      pass/cfapass.cpp
      pass/adhocpass.cpp
      contextrule.cpp
      query/containers.cpp
  	 pass/interpretationpass.cpp
      analysis/DominatorsTreeAnalysisProvider.cpp
      serialization/expressionserializer.cpp
 )
 
 set(XREATE_INCLUDE_DIRS
     ${CMAKE_CURRENT_SOURCE_DIR}/
 )
 
 INCLUDE_DIRECTORIES(${XREATE_INCLUDE_DIRS})
 
 set(XREATE_PRIVATE_INCLUDE_DIRS
     ${XREATE_INCLUDE_DIRS}
     ${COCO_GRAMMAR_PATH}
     ${JEAYESON_INCLUDE_PATH}
     ${LLVM_INCLUDE_DIRS}
     ${POTASSCO_INCLUDE_PATH}
 )
 
 add_library(${PROJECT_NAME} SHARED ${SOURCE_FILES} ${COCO_SOURCE_FILES})
 
 target_link_libraries(${PROJECT_NAME})
 
 
 target_include_directories(${PROJECT_NAME} INTERFACE 
     ${XREATE_INCLUDE_DIRS}
     ${COCO_GRAMMAR_PATH}
     ${JEAYESON_INCLUDE_PATH}
     ${LLVM_INCLUDE_DIRS}
     ${POTASSCO_INCLUDE_PATH}
 )
 
 get_directory_property(DEFINITIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_DEFINITIONS)
 message("definitions all: " ${DEFINITIONS_ALL})
 target_compile_definitions(${PROJECT_NAME} INTERFACE ${DEFINITIONS_ALL})
 
 get_directory_property(COMPILATION_OPTIONS_ALL DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} COMPILE_OPTIONS)
 message("compilations all: " ${COMPILATION_OPTIONS_ALL})
 target_compile_options(${PROJECT_NAME} INTERFACE ${COMPILATION_OPTIONS_ALL})
 
 SET_PROPERTY(TARGET ${PROJECT_NAME} PROPERTY
     INTERFACE_LINK_LIBRARIES ${LIBCLASP_LIBS} ${CLANG_LIBS} ${LLVM_LIBS}    tbb
 )
 
 #${CLANG_LIBS}
 
 
 #set (LINK_INTERFACE_LIBRARIES "")
 
 # FUNCTION(PREPEND var prefix)
 #    SET(listVar "")
 #    FOREACH(f ${ARGN})
 #       LIST(APPEND listVar "${prefix}/${f}")
 #    ENDFOREACH(f)
 #    SET(${var} "${listVar}" PARENT_SCOPE)
 # ENDFUNCTION(PREPEND)
 
 #set(COTIRE_UNITY_SOURCE_MAXIMUM_NUMBER_OF_INCLUDES "-j4")
 #cotire(xreate)
 
 
 # MACRO (ADD_PCH_RULE  _header_filename _src_list)
 # 	SET(_gch_filename "${_header_filename}.gch")
 # 	LIST(APPEND ${_src_list} ${_gch_filename})
 # 	SET (_args ${CMAKE_CXX_FLAGS})
 # 	LIST(APPEND _args -c ${_header_filename} -o ${_gch_filename})
 # 	GET_DIRECTORY_PROPERTY(DIRINC INCLUDE_DIRECTORIES)
 # 	foreach (_inc ${DIRINC})
 # 		LIST(APPEND _args "-I" ${_inc})
 # 	endforeach(_inc ${DIRINC})
 # 	SEPARATE_ARGUMENTS(_args)
 # 	add_custom_command(OUTPUT ${_gch_filename}
 # 		   COMMAND rm -f ${_gch_filename}
 # 		   COMMAND ${CMAKE_CXX_COMPILER} ${CMAKE_CXX_COMPILER_ARG1} ${_args}
 # 			    DEPENDS ${_header_filename})
 # ENDMACRO(ADD_PCH_RULE _header_filename _src_list)
 
 # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/ast.h SOURCE_FILES)
 # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/llvmlayer.h SOURCE_FILES)
 # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/clasplayer.h SOURCE_FILES)
 # ADD_PCH_RULE (${CMAKE_HOME_DIRECTORY}/src/pass/abstractpass.h SOURCE_FILES)
diff --git a/cpp/src/ast.h b/cpp/src/ast.h
index 7407463..8c24e48 100644
--- a/cpp/src/ast.h
+++ b/cpp/src/ast.h
@@ -1,558 +1,556 @@
 #ifndef AST_H
 #define AST_H
 
 #include "attachments.h"
 
 #include <vector>
 #include <stdlib.h>
 #include <string>
 #include <list>
 #include <unordered_map>
 #include <unordered_set>
 #include <climits>
 #include "utils.h"
 #include <algorithm>
 
 namespace llvm {
     class Value;
 }
 
 namespace xreate {
 
 struct String_t {
 };
 
 struct Identifier_t {
 };
 
 struct Number_t {
 };
 
 struct Type_t {
 };
 
 template<typename A>
 class Atom {
 };
 
 //DEBT hold for all atoms/identifiers Parser::Token data, like line:col position
 template<> class 
 Atom<Identifier_t> {
 public:
     Atom(const std::wstring& value);
     Atom(std::string && name);
     const std::string& get() const;
     
 private:
     std::string __value;
 };
 
 template<> 
 class Atom<Number_t> {
 public:
     Atom(wchar_t* value);
     Atom(int value);
     double get()const;
     
 private:
     double __value;
 };
 
 template<> 
 class Atom<String_t> {
 public:
     Atom(const std::wstring& value);
     const std::string& get() const;
 
 private:
     std::string __value;
 };
 
 enum class TypePrimitive {
-    Invalid, Bool, I8, I32, Num, Int, Float, String
+    Invalid, Bool, I8, I32, I64, Num, Int, Float, String
 };
 
     enum class TypeOperator {
         NONE, CALL, CUSTOM, VARIANT, ARRAY, TUPLE, STRUCT, ACCESS, LINK
     };
 
     struct llvm_array_tag {
     };
 
     struct struct_tag {
     };
     const llvm_array_tag tag_array = llvm_array_tag();
     const struct_tag tag_struct = struct_tag();
 
     class TypeAnnotation {
     public:
         TypeAnnotation();
         TypeAnnotation(const Atom<Type_t>& typ);
         TypeAnnotation(TypePrimitive typ);
         TypeAnnotation(llvm_array_tag, TypeAnnotation typ, int size);
 
         TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands);
         TypeAnnotation(TypeOperator op, std::vector<TypeAnnotation>&& operands);
         void addBindings(std::vector<Atom<Identifier_t>>&& params);
         void addFields(std::vector<Atom<Identifier_t>>&& listFields);
         bool operator<(const TypeAnnotation& t) const;
         //   TypeAnnotation (struct_tag, std::initializer_list<TypePrimitive>);
 
         bool isValid() const;
 
         TypeOperator __operator = TypeOperator::NONE;
 
         std::vector<TypeAnnotation> __operands;
         TypePrimitive __value;
         std::string __valueCustom;
         int conjuctionId = -1; //conjunction point id (relevant for recursive types)
 
         uint64_t __size = 0;
         std::vector<std::string> fields;
         std::vector<std::string> bindings;
     private:
     };
 
     enum class Operator {
         ADD, SUB, MUL, DIV,
         EQU, NE, NEG, LSS, 
         LSE, GTR, GTE, LIST, 
         LIST_RANGE, LIST_NAMED, 
         CALL, CALL_INTRINSIC, NONE, 
         IMPL/* implication */, MAP, 
         FOLD, FOLD_INF, LOOP_CONTEXT, 
         INDEX, IF, SWITCH, SWITCH_ADHOC, 
         CASE, CASE_DEFAULT, LOGIC_AND, 
         ADHOC, CONTEXT_RULE
     };
 
     class Function;
     class AST;
     class CodeScope;
     class MetaRuleAbstract;
 
     template<class Target>
     struct ManagedPtr {
 
         static ManagedPtr<Target> Invalid() {
             return ManagedPtr<Target>();
         }
 
         ManagedPtr() : __storage(0) {
         }
 
         ManagedPtr(unsigned int id, const std::vector<Target*>* storage)
         : __id(id), __storage(storage) {
         }
 
         Target&
         operator*() const {
             assert(isValid() && "Invalid Ptr");
             return *__storage->at(__id);
         }
 
         void operator=(const ManagedPtr<Target>& other) {
             __id = other.__id;
             __storage = other.__storage;
         }
 
         bool
         operator==(const ManagedPtr<Target>& other) {
             return isValid() && (__id == other.__id);
         }
 
         Target*
         operator->() const noexcept {
             assert(isValid() && "Invalid Ptr");
             return __storage->at(__id);
         }
 
         inline bool isValid() const {
             return (__storage) && (0 <= __id) && (__id < __storage->size());
         }
 
         inline operator bool() const {
             return isValid();
         }
 
         ManagedPtr<Target>& operator++() {
             ++__id;
             return *this;
         }
 
         inline unsigned int id() const {
             return __id;
         }
 
     private:
         unsigned int __id = 0;
         const std::vector<Target*> * __storage = 0;
     };
 
     typedef ManagedPtr<Function> ManagedFnPtr;
     typedef ManagedPtr<CodeScope> ManagedScpPtr;
     typedef ManagedPtr<MetaRuleAbstract> ManagedRulePtr;
     const ManagedScpPtr NO_SCOPE = ManagedScpPtr(UINT_MAX, 0);
 
     //To update ExpressionHints in case of any changes 
     struct Expression {
         friend class CodeScope;
         friend class ClaspLayer;
         friend class CFAPass;
         friend class ExpressionHints;
 
         Expression(const Operator &oprt, std::initializer_list<Expression> params);
         Expression(const Atom<Identifier_t>& ident);
         Expression(const Atom<Number_t>& number);
         Expression(const Atom<String_t>& a);
         
         Expression();
 
         void setOp(Operator oprt);
         void addArg(Expression&& arg);
         void addBindings(std::initializer_list<Atom<Identifier_t>> params);
         void bindType(TypeAnnotation t);
 
         template<class InputIt>
         void addBindings(InputIt paramsBegin, InputIt paramsEnd);
         void addTags(const std::list<Expression> tags) const;
         void addBlock(ManagedScpPtr scope);
 
         const std::vector<Expression>& getOperands() const;
         double getValueDouble() const;
         void setValueDouble(double value);
         const std::string& getValueString() const;
         void setValue(const Atom<Identifier_t>&& v);
         bool isValid() const;
         bool isDefined() const;
         
 
         bool operator==(const Expression& other) const;
 
         enum {
             INVALID, COMPOUND, IDENT, NUMBER, STRING, VARIANT, BINDING
         } __state = INVALID;
         
         Operator op;
         unsigned int id;
         std::vector<std::string> bindings;
         std::map<std::string, size_t> __indexBindings;
         std::vector<Expression> operands;
         TypeAnnotation type;
 
         mutable std::map<std::string, Expression> tags;
         std::list<CodeScope*> blocks;
 
     private:
         std::string __valueS;
         double __valueD;
         
         static unsigned int nextVacantId;
     };
     
     bool operator< (const Expression&, const Expression&);
 
     template<class InputIt>
     void Expression::addBindings(InputIt paramsBegin, InputIt paramsEnd) {
         size_t index = bindings.size();
 
         std::transform(paramsBegin, paramsEnd, std::inserter(bindings, bindings.end()),
                 [&index, this] (const Atom<Identifier_t> atom) {
                     std::string key = atom.get();
                     this->__indexBindings[key] = index++;
                     return key;
                 });
     }
 
     typedef std::list<Expression> ExpressionList;
 
     enum class TagModifier {
         NONE, ASSERT, REQUIRE
     };
 
     enum class DomainAnnotation {
         FUNCTION, VARIABLE
     };
 
     class RuleArguments : public std::vector<std::pair<std::string, DomainAnnotation>>
     {
         public:
         void add(const Atom<Identifier_t>& name, DomainAnnotation typ);
     };
 
     class RuleGuards : public std::vector<Expression> {
     public:
         void add(Expression&& e);
     };
 
 
     class ClaspLayer;
     class LLVMLayer;
 
     class MetaRuleAbstract {
     public:
         MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards);
         virtual ~MetaRuleAbstract();
         virtual void compile(ClaspLayer& layer) = 0;
     protected:
         RuleArguments __args;
         RuleGuards __guards;
     };
 
     class RuleWarning : public MetaRuleAbstract {
         friend class ClaspLayer;
     public:
         RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message);
         virtual void compile(ClaspLayer& layer);
         ~RuleWarning();
 
     private:
         std::string __message;
         Expression __condition;
     };
 
     typedef unsigned int VNameId;
     
     typedef int VariableVersion;
     const VariableVersion VERSION_NONE = -2;
     const VariableVersion VERSION_INIT = 0;
     
     template<>
     struct AttachmentsDict<VariableVersion>
     {
         typedef VariableVersion Data;
         static const unsigned int key = 6;
     };
     
     struct ScopedSymbol{
         VNameId id;
         VariableVersion version;
         
         static const ScopedSymbol RetSymbol;
     };
     
     struct Symbol {
         ScopedSymbol identifier;
         CodeScope * scope;
     };
     
     template<>
     struct AttachmentsDict<Symbol>
     {
         typedef Symbol Data;
         static const unsigned int key = 7;
     };
     
 } 
 namespace std
 {
     template<>
     struct hash<xreate::ScopedSymbol>{
         std::size_t operator()(xreate::ScopedSymbol const& s) const;
     };
 
     template<>
     struct equal_to<xreate::ScopedSymbol>{
       bool operator()(const xreate::ScopedSymbol& __x, const xreate::ScopedSymbol& __y) const;
     };
 }
 
 namespace xreate {
 
     
     typedef std::pair<Expression, TagModifier> Tag;
 
     bool operator<(const ScopedSymbol& s1, const ScopedSymbol& s2);
     bool operator==(const ScopedSymbol& s1, const ScopedSymbol& s2);
     bool operator<(const Symbol& s1, const Symbol& s2);
     bool operator==(const Symbol& s1, const Symbol& s2);
 
 class CodeScope {
     friend class Function;
     friend class PassManager;
 
 public:
     CodeScope(CodeScope* parent = 0);
     void setBody(const Expression& body);
     Expression& getBody();
     void addDeclaration(Expression&& var, Expression&& body);
     void addBinding(Expression&& var, Expression&& argument);
     static const Expression& getDeclaration(const Symbol& symbol);
     const Expression& getDeclaration(const ScopedSymbol& symbol);
 
     ~CodeScope();
 
     std::vector<std::string> __bindings;
     std::map<std::string, VNameId> __identifiers;
+    CodeScope* __parent;
 
     //TODO move __definitions to SymbolsAttachments data
     //NOTE: definition of return type has zero(0) variable index
     std::unordered_map<ScopedSymbol, Expression> __declarations;
     std::vector<Expression> tags;
     std::vector<Expression> contextRules;
-
 private:
     VNameId __vCounter = 1;
-    CodeScope* __parent;
-
     ScopedSymbol registerIdentifier(const Expression& identifier);
 
 public:
     bool recognizeIdentifier(const Expression& identifier) const;
     ScopedSymbol getSymbol(const std::string& alias);
 };
 
 class Function {
     friend class Expression;
     friend class CodeScope;
     friend class AST;
 
 public:
     Function(const Atom<Identifier_t>& name);
 
     void addBinding(Atom <Identifier_t>&& name, Expression&& argument);
     void addTag(Expression&& tag, const TagModifier mod);
 
     const std::string& getName() const;
     const std::map<std::string, Expression>& getTags() const;
     CodeScope* getEntryScope() const;
     CodeScope* __entry;
     std::string __name;
     bool isPrefunction = false; //SECTIONTAG adhoc Function::isPrefunction flag
 
     Expression guardContext;
 private:
 
     std::map<std::string, Expression> __tags;
 };
 
 
 class ExternData;
 
 struct ExternEntry {
     std::string package;
     std::vector<std::string> headers;
 };
 
 typedef Expanded<TypeAnnotation> ExpandedType;
 
 enum ASTInterface {
     CFA, DFA, Extern, Adhoc
 };
 
 struct FunctionSpecialization {
     std::string guard;
     size_t id;
 };
 
 struct FunctionSpecializationQuery {
     std::unordered_set<std::string> context;
 };
 
 template<>
 struct AttachmentsId<Expression>{
     static unsigned int getId(const Expression& expression){
         return expression.id;
     }
 };
 
 template<>
 struct AttachmentsId<Symbol>{
     static unsigned int getId(const Symbol& s){
         return s.scope->__declarations.at(s.identifier).id;
     }
 };
 
 template<>
 struct AttachmentsId<ManagedFnPtr>{
     static unsigned int getId(const ManagedFnPtr& f){
         const Symbol symbolFunction{ScopedSymbol::RetSymbol, f->getEntryScope()};
         
         return AttachmentsId<Symbol>::getId(symbolFunction);
     }
 };
 
 class AST {
 public:
     AST();
 
     //TASK extern and DFA interfaces move into addInterfaceData
     /**
      *  DFA Interface
      */
     void addDFAData(Expression&& data);
 
     /**
      * Extern Interface
      */
     void addExternData(ExternData&& data);
 
     void addInterfaceData(const ASTInterface& interface, Expression&& data);
     void add(Function* f);
 
     void add(MetaRuleAbstract* r);
     ManagedScpPtr add(CodeScope* scope);
 
     std::string getModuleName();
     ManagedPtr<Function> findFunction(const std::string& name);
 
     typedef std::multimap<std::string, unsigned int> FUNCTIONS_REGISTRY;
     std::list<ManagedFnPtr> getAllFunctions() const;
     std::list<ManagedFnPtr> getFunctionVariants(const std::string& name) const;
 
 
     template<class Target>
     ManagedPtr<Target> begin();
 
     std::vector<ExternEntry> __externdata;
     std::list<Expression> __dfadata; //TODO move to more appropriate place
     std::list<std::string> __rawImports; //TODO move to more appropriate place
     std::multimap<ASTInterface, Expression> __interfacesData; //TODO CFA data here.
 
 private:
     std::vector<MetaRuleAbstract*> __rules;
     std::vector<Function*> __functions;
     std::vector<CodeScope*> __scopes;
 
     FUNCTIONS_REGISTRY __indexFunctions;
 
 
     // ***** TYPES SECTION *****
 public:
     std::map<std::string, TypeAnnotation> __indexTypeAliases;
     ExpandedType expandType(const TypeAnnotation &t) const;
     ExpandedType findType(const std::string& name);
     void add(TypeAnnotation t, Atom<Identifier_t> alias);
 
     //TODO revisit enums/variants, move to codescope
     bool recognizeVariantIdentifier(Expression& identifier);
 
 
 private:
     std::map<std::string, std::pair<TypeAnnotation, int>> __dictVariants;
     ExpandedType expandType(const TypeAnnotation &t, std::map<std::string, TypeAnnotation> scope,
             const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) const;
 
     // ***** SYMBOL RECOGNITION *****
 public:
     std::set<std::pair<CodeScope*, Expression>> binUnrecognizedIdentifiers;
 
 public:
     void postponeIdentifier(CodeScope* scope, const Expression& id);
     void recognizePostponedIdentifiers();
 };
 
 template<>
 ManagedPtr<Function>
 AST::begin<Function>();
 
 template<>
 ManagedPtr<CodeScope>
 AST::begin<CodeScope>();
 
 template<>
 ManagedPtr<MetaRuleAbstract>
 AST::begin<MetaRuleAbstract>();
 
 }
 #endif // AST_H
diff --git a/cpp/src/compilation/advanced.cpp b/cpp/src/compilation/advanced.cpp
index d5183a8..c83705f 100644
--- a/cpp/src/compilation/advanced.cpp
+++ b/cpp/src/compilation/advanced.cpp
@@ -1,403 +1,404 @@
 /*
  * File:   InstructionsAdvanced.cpp
  * Author: pgess
  *
  * Created on June 26, 2016, 6:00 PM
  */
 
 //#include <compilation/transformations.h>
 #include "compilation/advanced.h"
 #include "compilation/containers.h"
 #include "compilation/transformersaturation.h"
 
 #include "query/context.h"
 #include "query/containers.h"
 #include "llvmlayer.h"
 #include "ast.h"
 
 using namespace std;
 using namespace llvm;
 using namespace xreate;
 using namespace xreate::containers;
 using namespace xreate::compilation;
 
 #define NAME(x) (hintRetVar.empty()? x : hintRetVar)
 #define UNUSED(x) (void)(x)
 #define EXPAND_CONTEXT         \
     LLVMLayer* llvm = context.pass->man->llvm; \
     compilation::AbstractCodeScopeUnit* scope = context.scope; \
     compilation::FunctionUnit* function = context.function;
 
 Advanced::Advanced(compilation::Context ctx)
 : context(ctx), tyNum(static_cast<llvm::IntegerType*> (ctx.pass->man->llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::Num))))) {
 }
 
 llvm::Value*
 Advanced::compileMapSolidOutput(const Expression &expr, const std::string hintRetVar) {
     EXPAND_CONTEXT
 
     //initialization
     Symbol symbolIn = Attachments::get<Symbol>(expr.getOperands()[0]);
 
     ImplementationRec<SOLID> implIn = containers::Query::queryImplementation(symbolIn).extract<SOLID>(); // impl of input list
     size_t size = implIn.size;
     CodeScope* scopeLoop = expr.blocks.front();
     std::string varEl = scopeLoop->__bindings[0];
 
     Iterator* it = Iterator::create(context, symbolIn);
     llvm::Value *rangeFrom = it->begin();
     llvm::Value *rangeTo = it->end();
 
     //definitions
     ArrayType* tyNumArray = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::Num, size))));
     llvm::IRBuilder<> &builder = llvm->builder;
 
     llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "loop", function->raw);
     llvm::BasicBlock *blockBeforeLoop = builder.GetInsertBlock();
     llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "postloop", function->raw);
     Value* dataOut = llvm->builder.CreateAlloca(tyNumArray, ConstantInt::get(tyNum, size), NAME("map"));
 
     // * initial check
     Value* condBefore = builder.CreateICmpSLE(rangeFrom, rangeTo);
     builder.CreateCondBr(condBefore, blockLoop, blockAfterLoop);
 
     // create PHI:
     builder.SetInsertPoint(blockLoop);
     llvm::PHINode *stateLoop = builder.CreatePHI(tyNum, 2, "mapIt");
     stateLoop->addIncoming(rangeFrom, blockBeforeLoop);
 
     // loop body:
     Value* elIn = it->get(stateLoop, varEl);
     compilation::AbstractCodeScopeUnit* scopeLoopUnit = function->getScopeUnit(scopeLoop);
     scopeLoopUnit->bindArg(elIn, move(varEl));
     Value* elOut = scopeLoopUnit->compile();
     Value *pElOut = builder.CreateGEP(dataOut, ArrayRef<Value *>(std::vector<Value*>{ConstantInt::get(tyNum, 0), stateLoop}));
     builder.CreateStore(elOut, pElOut);
 
     //next iteration preparing
     Value *stateLoopNext = builder.CreateAdd(stateLoop, llvm::ConstantInt::get(tyNum, 1));
     stateLoop->addIncoming(stateLoopNext, builder.GetInsertBlock());
 
     //next iteration checks:
     Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
     builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);
 
     //finalization:
     builder.SetInsertPoint(blockAfterLoop);
 
     return dataOut;
 }
 
 Value*
 Advanced::compileArrayIndex(llvm::Value* aggregate, std::vector<llvm::Value *> indexes, std::string hintRetVar) {
     EXPAND_CONTEXT
     UNUSED(function);
 
     indexes.insert(indexes.begin(), llvm::ConstantInt::get(tyNum, 0));
     llvm::Value *pEl = llvm->builder.CreateGEP(aggregate, llvm::ArrayRef<llvm::Value *>(indexes));
     return llvm->builder.CreateLoad(pEl, NAME("el"));
 }
 
 Value*
 Advanced::compileStructIndex(llvm::Value* aggregate, const ExpandedType& t, const std::string& idx) {
     EXPAND_CONTEXT
     UNUSED(scope);
 
 
     TypeUtils types(llvm);
 
     std::vector<std::string>&& fields = types.getStructFields(t);
     for (unsigned i = 0, size = fields.size(); i < size; ++i) {
         if (fields.at(i) == idx) {
 
             std::vector<llvm::Value*> refs;
 
             llvm::IntegerType* tyInt = llvm::Type::getInt32Ty(llvm::getGlobalContext());
             llvm::ConstantInt* zero = llvm::ConstantInt::get(tyInt, 0, false);
 
             llvm::BasicBlock *blockSafe = llvm::BasicBlock::Create(llvm::getGlobalContext(), "safe", function->raw);
 
 
             // TODO review safety check: validPtr for `aggregate`
             // SECTIONTAG validptr exception
             PointerType* tyAggr = dyn_cast<PointerType>(aggregate->getType());
             llvm::Value* null = llvm::ConstantPointerNull::get(tyAggr);
             Value* condNull = llvm->builder.CreateICmpNE(aggregate, null);
 
             llvm::BasicBlock *blockException = llvm::BasicBlock::Create(llvm::getGlobalContext(), "exception", function->raw);
             llvm->builder.CreateCondBr(condNull, blockSafe, blockException);
             llvm->initExceptionBlock(blockException);
 
             llvm->builder.SetInsertPoint(blockSafe);
             std::vector<Value*> indexes;
 
             //dereference pointer
             if (types.isPointer(t)) {
                 indexes.push_back(zero);
             }
 
             indexes.push_back(ConstantInt::get(tyInt, i));
 
             Value* addr = llvm->builder.CreateGEP(aggregate, indexes);
             return llvm->builder.CreateLoad(addr);
         }
     }
 
     assert(false && "not found required struct field");
     return nullptr;
 }
 
 llvm::Value*
 Advanced::compileFold(const Expression& fold, const std::string& hintRetVar) {
     EXPAND_CONTEXT
     assert(fold.op == Operator::FOLD);
 
     //initialization:
     Symbol varInSymbol = Attachments::get<Symbol>(fold.getOperands()[0]);
     Implementation info = Query::queryImplementation(varInSymbol);
 
     Iterator* it = Iterator::create(context, varInSymbol);
     llvm::Value* rangeBegin = it->begin();
     llvm::Value* rangeEnd = it->end();
     llvm::Value* accumInit = scope->process(fold.getOperands()[1]);
     std::string varIn = fold.getOperands()[0].getValueString();
     std::string varAccum = fold.bindings[1];
     std::string varEl = fold.bindings[0];
 
     llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
     std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));
 
 
     llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold", function->raw);
     llvm::BasicBlock *blockLoopBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_body", function->raw);
     llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_after", function->raw);
     llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold_next", function->raw);
 
     llvm->builder.CreateBr(blockLoop);
 
     // * create phi
     llvm->builder.SetInsertPoint(blockLoop);
     llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, varAccum);
     accum->addIncoming(accumInit, blockBeforeLoop);
     llvm::PHINode *itLoop = llvm->builder.CreatePHI(rangeBegin->getType(), 2, "foldIt");
     itLoop->addIncoming(rangeBegin, blockBeforeLoop);
 
     // * loop checks
     Value* condRange = llvm->builder.CreateICmpNE(itLoop, rangeEnd);
     llvm->builder.CreateCondBr(condRange, blockLoopBody, blockAfterLoop);
 
     // * loop body
     llvm->builder.SetInsertPoint(blockLoopBody);
     CodeScope* scopeLoop = fold.blocks.front();
     compilation::AbstractCodeScopeUnit* loopUnit = function->getScopeUnit(scopeLoop);
     Value* elIn = it->get(itLoop);
     loopUnit->bindArg(accum, move(varAccum));
     loopUnit->bindArg(elIn, move(varEl));
     Value* accumNext = loopUnit->compile();
 
     // * Loop saturation checks
     bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
     llvm::BasicBlock* blockSaturation = llvm->builder.GetInsertBlock();
     if (!flagSaturationTriggered){
         llvm->builder.CreateBr(blockNext);
     }
 
     // * computing next iteration state
     llvm->builder.SetInsertPoint(blockNext);
     Value *itLoopNext = it->advance(itLoop);
     accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
     itLoop->addIncoming(itLoopNext, llvm->builder.GetInsertBlock());
     llvm->builder.CreateBr(blockLoop);
 
     // * finalization:
     llvm->builder.SetInsertPoint(blockAfterLoop);
     if (!flagSaturationTriggered){
         return accum;
     }
 
     llvm::PHINode* result = llvm->builder.CreatePHI(accumInit->getType(), 2);
     result->addIncoming(accum, blockLoop);
     result->addIncoming(accumNext, blockSaturation);
     return result;
 }
 
 llvm::Value*
 Advanced::compileFoldInf(const Expression& fold, const std::string& hintRetVar) {
     EXPAND_CONTEXT
     assert(fold.op == Operator::FOLD_INF);
 
     std::string accumName = fold.bindings[0];
     llvm::Value* accumInit = scope->process(fold.getOperands()[0]);
 
     llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
     llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf", function->raw);
     llvm::BasicBlock *blockNext = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_next", function->raw);
     llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "foldinf_post", function->raw);
     std::unique_ptr<TransformerSaturation> transformerSaturation(new TransformerSaturation(blockBeforeLoop, context.pass->managerTransformations));
 
     llvm->builder.CreateBr(blockLoop);
 
     // * create phi
     llvm->builder.SetInsertPoint(blockLoop);
     llvm::PHINode *accum = llvm->builder.CreatePHI(accumInit->getType(), 2, accumName);
     accum->addIncoming(accumInit, blockBeforeLoop);
 
     // * loop body
     CodeScope* scopeLoop = fold.blocks.front();
     compilation::AbstractCodeScopeUnit* unitLoop = function->getScopeUnit(scopeLoop);
     unitLoop->bindArg(accum, move(accumName));
     Value* accumNext = unitLoop->compile();
 
     // * Loop saturation checks
     bool flagSaturationTriggered = transformerSaturation->insertSaturationChecks(blockNext, blockAfterLoop, context);
     assert(flagSaturationTriggered);
 
     // * computing next iteration state
     llvm->builder.SetInsertPoint(blockNext);
     accum->addIncoming(accumNext, llvm->builder.GetInsertBlock());
     llvm->builder.CreateBr(blockLoop);
 
     // finalization:
     llvm->builder.SetInsertPoint(blockAfterLoop);
     return accumNext;
 }
 
 llvm::Value*
 Advanced::compileIf(const Expression& exprIf, const std::string& hintRetVar) {
     EXPAND_CONTEXT
 
             //initialization:
-            const Expression& condExpr = exprIf.getOperands()[0];
+    const Expression& condExpr = exprIf.getOperands()[0];
     llvm::IRBuilder<>& builder = llvm->builder;
     //llvm::Type* tyResultType = llvm->toLLVMType(llvm->ast->expandType(exprIf.type));
 
     llvm::BasicBlock *blockAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifAfter", function->raw);
     llvm::BasicBlock *blockTrue = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifTrue", function->raw);
     llvm::BasicBlock *blockFalse = llvm::BasicBlock::Create(llvm::getGlobalContext(), "ifFalse", function->raw);
 
     llvm::Value* cond = scope->process(condExpr);
     llvm->builder.CreateCondBr(cond, blockTrue, blockFalse);
 
     builder.SetInsertPoint(blockTrue);
     CodeScope* scopeTrue = exprIf.blocks.front();
     llvm::Value* resultTrue = function->getScopeUnit(scopeTrue)->compile();
     blockTrue = builder.GetInsertBlock();
     builder.CreateBr(blockAfter);
 
     builder.SetInsertPoint(blockFalse);
     CodeScope* scopeFalse = exprIf.blocks.back();
     llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
     blockFalse = builder.GetInsertBlock();
     builder.CreateBr(blockAfter);
 
     builder.SetInsertPoint(blockAfter);
     llvm::PHINode *ret = builder.CreatePHI(resultTrue->getType(), 2, NAME("if"));
+
     ret->addIncoming(resultTrue, blockTrue);
     ret->addIncoming(resultFalse, blockFalse);
 
     return ret;
 }
 
 //TODO Switch: default variant no needed when all possible conditions are considered
 
 llvm::Value*
 Advanced::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar) {
     EXPAND_CONTEXT
     UNUSED(function);
 
     assert(exprSwitch.operands.size() >= 2);
     assert(exprSwitch.operands[1].op == Operator::CASE_DEFAULT && "No default case in Switch Statement");
     int countCases = exprSwitch.operands.size() - 1;
     llvm::IRBuilder<>& builder = llvm->builder;
 
     llvm::BasicBlock* blockProlog = builder.GetInsertBlock();
     llvm::BasicBlock *blockEpilog = llvm::BasicBlock::Create(llvm::getGlobalContext(), "switchAfter", function->raw);
     builder.SetInsertPoint(blockEpilog);
     llvm::Type* exprSwitchType = llvm->toLLVMType(ExpandedType(exprSwitch.type));
     llvm::PHINode *ret = builder.CreatePHI(exprSwitchType, countCases, NAME("switch"));
 
     builder.SetInsertPoint(blockProlog);
     llvm::Value * conditionSwitch = scope->process(exprSwitch.operands[0]);
     llvm::BasicBlock *blockDefault = llvm::BasicBlock::Create(llvm::getGlobalContext(), "caseDefault", function->raw);
     llvm::SwitchInst * instructionSwitch = builder.CreateSwitch(conditionSwitch, blockDefault, countCases);
 
     for (int size = exprSwitch.operands.size(), i = 2; i < size; ++i) {
         llvm::BasicBlock *blockCase = llvm::BasicBlock::Create(llvm::getGlobalContext(), "case" + std::to_string(i), function->raw);
 
         llvm::Value* condCase = function->getScopeUnit(exprSwitch.operands[i].blocks.front())->compile();
         builder.SetInsertPoint(blockCase);
         llvm::Value* resultCase = function->getScopeUnit(exprSwitch.operands[i].blocks.back())->compile();
         builder.CreateBr(blockEpilog);
 
         ret->addIncoming(resultCase, builder.GetInsertBlock());
         builder.SetInsertPoint(blockProlog);
         instructionSwitch->addCase(dyn_cast<llvm::ConstantInt>(condCase), blockCase);
     }
 
     //compile default block:
     builder.SetInsertPoint(blockDefault);
     CodeScope* scopeDefault = exprSwitch.operands[1].blocks.front();
     llvm::Value* resultDefault = function->getScopeUnit(scopeDefault)->compile();
     builder.CreateBr(blockEpilog);
     ret->addIncoming(resultDefault, builder.GetInsertBlock());
     builder.SetInsertPoint(blockEpilog);
 
     return ret;
 }
 
 //TODO recognize cases to make const arrays/stored in global mem/stack alloced.
 llvm::Value*
 Advanced::compileListAsSolidArray(const Expression &expr, const std::string& hintRetVar) {
     EXPAND_CONTEXT
     UNUSED(scope);
     UNUSED(function);
 
     AST* root = context.pass->man->root;
     const size_t& length = expr.getOperands().size();
     const Expression& expression = expr;
     llvm::Value* zero = ConstantInt::get(tyNum, 0);
     llvm::Value* one = ConstantInt::get(tyNum, 1);
 
     ExpandedType typAggrExpanded = root->expandType(expression.type);
     assert(typAggrExpanded->__operator == TypeOperator::ARRAY);
     llvm::Type* typEl = llvm->toLLVMType(ExpandedType(typAggrExpanded->__operands[0]));
     ArrayType* typAggr = (ArrayType*) llvm::ArrayType::get(typEl, length);
     llvm::Value* list = llvm->builder.CreateAlloca(typAggr, ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), length, false), hintRetVar);
 
     const std::vector<Expression>& operands = expression.getOperands();
     llvm::Value* addrOperand = llvm->builder.CreateGEP(typAggr, list, ArrayRef<Value *>(std::vector<Value*>{zero, zero}));
     llvm->builder.CreateStore(scope->process(operands.front()), addrOperand) ;
     for (auto i=++operands.begin(); i!=operands.end(); ++i){
         addrOperand = llvm->builder.CreateGEP(typEl, addrOperand, ArrayRef<Value *>(std::vector<Value*>{one}));
         llvm->builder.CreateStore(scope->process(*i), addrOperand) ;
     }
 
     return list;
 //        Value* listDest = l.builder.CreateAlloca(typList, ConstantInt::get(typI32, __size), *hintRetVar);
 //        l.buil1der.CreateMemCpy(listDest, listSource, __size, 16);
 }
 
 llvm::Value*
         Advanced::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar) {
     EXPAND_CONTEXT
     UNUSED(function);
             UNUSED(scope);
 
             Type* typPchar = PointerType::getUnqual(Type::getInt8Ty(llvm::getGlobalContext()));
             //ArrayType* typStr = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I8, size+1))));
 
             /*
             std::vector<Constant *> chars;
             chars.reserve(size+1);
 
             for (size_t i=0; i< size; ++i){
                 chars[i] = ConstantInt::get(typI8, (unsigned char) data[i]);
             }
             chars[size] = ConstantInt::get(typI8, 0);
              */
 
             Value* rawData = ConstantDataArray::getString(llvm::getGlobalContext(), data);
             Value* rawPtrData = llvm->builder.CreateAlloca(rawData->getType(), ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 1, false));
             llvm->builder.CreateStore(rawData, rawPtrData);
     return llvm->builder.CreateCast(llvm::Instruction::BitCast, rawPtrData, typPchar, hintRetVar);
 }
diff --git a/cpp/src/compilation/pointerarithmetic.cpp b/cpp/src/compilation/pointerarithmetic.cpp
new file mode 100644
index 0000000..307c174
--- /dev/null
+++ b/cpp/src/compilation/pointerarithmetic.cpp
@@ -0,0 +1,31 @@
+/*
+ * pointerarithmetic.cpp
+ *
+ * Author: pgess <v.melnychenko@xreate.org>
+ * Created on March 29, 2017, 11:52 AM
+ */
+#include "pointerarithmetic.h"
+#include "llvmlayer.h"
+#include <vector>
+
+using namespace llvm;
+
+namespace xreate { namespace compilation {
+
+llvm::Value*
+PointerArithmetic::add(llvm::Value *left, llvm::Value *right, Context context, const std::string& hintVarDecl){
+    LLVMLayer* llvm = context.pass->man->llvm;
+
+    if (left->getType()->isPointerTy() && right->getType()->isIntegerTy()){
+
+        std::vector<llvm::Value*> indexes{right};
+        //{llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), 0)};
+        //indexes.push_back(right);
+
+        return llvm->builder.CreateGEP(left, llvm::ArrayRef<llvm::Value*>(indexes), hintVarDecl);
+    }
+
+    return nullptr;
+}
+
+} }
\ No newline at end of file
diff --git a/cpp/src/compilation/pointerarithmetic.h b/cpp/src/compilation/pointerarithmetic.h
new file mode 100644
index 0000000..5302d7b
--- /dev/null
+++ b/cpp/src/compilation/pointerarithmetic.h
@@ -0,0 +1,29 @@
+/* 
+ * File:   pointerarithmetic.h
+ * Author: pgess <v.melnychenko@xreate.org>
+ *
+ * Created on March 29, 2017, 11:52 AM
+ */
+
+#ifndef POINTERARITHMETIC_H
+#define POINTERARITHMETIC_H
+
+#include "pass/compilepass.h"
+
+namespace llvm {
+    class Value;
+}
+
+namespace xreate { namespace compilation {
+    
+class PointerArithmetic {
+public:
+    static llvm::Value* add(llvm::Value *left, llvm::Value *right, Context context, const std::string& hintVarDecl);
+};
+   
+    
+} }
+
+
+#endif /* POINTERARITHMETIC_H */
+
diff --git a/cpp/src/compilation/scopedecorators.h b/cpp/src/compilation/scopedecorators.h
index 612d68a..ac469ad 100644
--- a/cpp/src/compilation/scopedecorators.h
+++ b/cpp/src/compilation/scopedecorators.h
@@ -1,123 +1,129 @@
 /* 
  * File:   scopedecorators.h
  * Author: pgess <v.melnychenko@xreate.org>
  *
  * Created on February 24, 2017, 11:35 AM
  */
 
 #ifndef SCOPEDECORATORS_H
 #define SCOPEDECORATORS_H
 
 #include "ast.h"
 #include "compilation/targetinterpretation.h"
 #include "compilation/versions.h"
 #include "compilation/transformations.h"
 
 namespace xreate { 
     
 class CompilePass;
 
 namespace compilation {
 
 class AbstractCodeScopeUnit;
 class FunctionUnit;
 
 template<class Parent>
 class CachedScopeDecorator: public Parent{
     typedef CachedScopeDecorator<Parent> SELF;
 
 public:
     CachedScopeDecorator(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass): Parent(codeScope, f, compilePass){}
 
-    void reset(){
-        __rawVars.clear();
-    }
-    
     void bindArg(llvm::Value* value, std::string&& alias)
     {
         //ensure existence of an alias
         assert(Parent::scope->__identifiers.count(alias));
 
         //memorize new value for an alias
         ScopedSymbol id{Parent::scope->__identifiers.at(alias), VERSION_NONE};
         __rawVars[id] = value;
     }
 
     void bindArg(llvm::Value* value, const ScopedSymbol& s) {
         __rawVars[s] = value;
     }
     
     llvm::Value* compile(const std::string& hintBlockDecl="") override{
         if (__rawVars.count(ScopedSymbol::RetSymbol)){
             return __rawVars[ScopedSymbol::RetSymbol];
         }
         
         return Parent::compile(hintBlockDecl);
     }
 
     llvm::Value* 
     processSymbol(const Symbol& s, std::string hintRetVar) override{
         CodeScope* scope = s.scope;
         SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(scope));
 
         if (self->__rawVars.count(s.identifier)){
             return self->__rawVars[s.identifier];
         }
 
         //Declaration could be overriden
         Expression declaration = CodeScope::getDeclaration(s);
         if (!declaration.isDefined()){
             if (self->__declarationsOverriden.count(s.identifier)){
                 declaration = self->__declarationsOverriden[s.identifier];
 
             } else {
                 assert(false); //in case of binding there should be raws provided.
             }
         }
 
         return self->__rawVars[s.identifier] = Parent::processSymbol(s, hintRetVar);
     }
 
     void 
     overrideDeclaration(const Symbol binding, Expression&& declaration){
         SELF* self = dynamic_cast<SELF*>(Parent::function->getScopeUnit(binding.scope));
 
         self->__declarationsOverriden.emplace(binding.identifier, std::move(declaration));
     }
 
+    void registerChildScope(std::shared_ptr<AbstractCodeScopeUnit> scope){
+        __childScopes.push_back(scope);
+    }
+
+    void reset(){
+        __rawVars.clear();
+        __declarationsOverriden.clear();
+        __childScopes.clear();
+    }
+
 private:
     std::unordered_map<ScopedSymbol, Expression> __declarationsOverriden;
     std::unordered_map<ScopedSymbol,llvm::Value*> __rawVars;
-
+    std::list<std::shared_ptr<AbstractCodeScopeUnit>> __childScopes;
 };
 
 typedef CachedScopeDecorator<
         compilation::TransformationsScopeDecorator<
         compilation::InterpretationScopeDecorator<
         compilation::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>>
 
         DefaultScopeUnit;
 
 } //end of compilation namespace
 
 struct CachedScopeDecoratorTag;
 struct VersionsScopeDecoratorTag;
 
 template<>
 struct DecoratorsDict<CachedScopeDecoratorTag>{
     typedef compilation::CachedScopeDecorator<
             compilation::TransformationsScopeDecorator<
             compilation::InterpretationScopeDecorator<
             compilation::VersionsScopeDecorator<compilation::BasicCodeScopeUnit>>>> result;
 };
 
 template<>
 struct DecoratorsDict<VersionsScopeDecoratorTag>{
     typedef compilation::VersionsScopeDecorator<
             compilation::BasicCodeScopeUnit> result;
 };
 
 } //end of xreate
 
 #endif /* SCOPEDECORATORS_H */
 
diff --git a/cpp/src/compilation/targetinterpretation.cpp b/cpp/src/compilation/targetinterpretation.cpp
index 2969498..937a400 100644
--- a/cpp/src/compilation/targetinterpretation.cpp
+++ b/cpp/src/compilation/targetinterpretation.cpp
@@ -1,432 +1,436 @@
 /*
  * File:   targetinterpretation.cpp
  * Author: pgess
  *
  * Created on June 29, 2016, 6:45 PM
  */
 
 #include "compilation/targetinterpretation.h"
 #include "pass/interpretationpass.h"
 #include "llvmlayer.h"
 #include "compilation/scopedecorators.h"
 
 #include <boost/scoped_ptr.hpp>
 #include <iostream>
 #include <clang/AST/DeclBase.h>
 
 using namespace std;
 
 namespace xreate{ namespace compilation {
 
     const Expression EXPRESSION_FALSE = Expression(Atom<Number_t>(0));
     const Expression EXPRESSION_TRUE = Expression(Atom<Number_t>(1));
 
 //Expression
 //InterpretationScope::compile(const Expression& expression){}
 
 CodeScope*
 InterpretationScope::processOperatorIf(const Expression& expression){
     const Expression& exprCondition = process(expression.getOperands()[0]);
 
     if (exprCondition == EXPRESSION_TRUE){
         return expression.blocks.front();
     }
 
     return expression.blocks.back();
 }
 
 CodeScope*
 InterpretationScope::processOperatorSwitch(const Expression& expression) {
     const Expression& exprCondition = process(expression.operands[0]);
 
     bool flagHasDefault = expression.operands[1].op == Operator::CASE_DEFAULT;
 
     //TODO check that one and only one case variant is appropriate
     for (size_t size = expression.operands.size(), i= flagHasDefault? 2: 1; i<size; ++i){
         const Expression& exprCase = process(expression.operands[i]);
 
         if (function->getScope(exprCase.blocks.front())->processScope() == exprCondition){
             return exprCase.blocks.back();
         }
     }
 
     if (flagHasDefault){
         const Expression& exprCaseDefault = expression.operands[1];
         return exprCaseDefault.blocks.front();
     }
 
     assert(false && "Switch has no appropriate variant");
     return nullptr;
 }
 
 llvm::Value*
 InterpretationScope::compileHybrid(const InterpretationOperator& op, const Expression& expression, const Context& context){
     switch(op){
         case IF_INTERPRET_CONDITION: {
             CodeScope* scopeResult = processOperatorIf(expression);
 
             llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
             return result;
         }
 
         case SWITCH_INTERPRET_CONDITION:{
             CodeScope* scopeResult = processOperatorSwitch(expression);
 
             llvm::Value* result = context.function->getScopeUnit(scopeResult)->compile();
             return result;
         }
 
         case FOLD_INTERPRET_INPUT: {
             //initialization
             const Expression& exprInput = process(expression.getOperands()[0]);
             assert(exprInput.op == Operator::LIST);
 
             CodeScope* scopeBody = expression.blocks.front();
 
             const string& nameEl = expression.bindings[0];
             Symbol symbEl{ScopedSymbol{scopeBody->__identifiers.at(nameEl), VERSION_NONE}, scopeBody};
             const std::string& idAccum = expression.bindings[1];
             llvm::Value* rawAccum = context.scope->process(expression.getOperands()[1]);
-            auto unitBody = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeBody));
+
             InterpretationScope* intrBody = function->getScope(scopeBody);
+            auto unitBody = Decorators<CachedScopeDecoratorTag>::getInterface(context.function->getScopeUnit(scopeBody));
+
             const std::vector<Expression> elementsInput= exprInput.getOperands();
 
             for (size_t i=0; i<elementsInput.size(); ++i){
-                Expression exprElement  = elementsInput[i];
+                intrBody->reset();
                 unitBody->reset();
 
+                Expression exprElement  = elementsInput[i];
+
                 intrBody->overrideBinding(exprElement, nameEl);
                 unitBody->overrideDeclaration(symbEl, move(exprElement));
                 unitBody->bindArg(rawAccum, string(idAccum));
 
                 rawAccum = unitBody->compile();
             }
 
             return rawAccum;
         }
 
         case CALL_INTERPRET_PARTIAL: {
             const std::string &calleeName = expression.getValueString();
             AbstractCodeScopeUnit* scopeUnitSelf = context.scope;
             ManagedFnPtr callee = this->function->man->ast->findFunction(calleeName);
             const  FunctionInterpretationData& calleeData = FunctionInterpretationHelper::getSignature(callee);
             std::vector<llvm::Value *> argsActual;
             PIFSignature sig;
             sig.declaration = callee;
 
             for(size_t no=0, size = expression.operands.size(); no < size; ++no){
                 const Expression& op =  expression.operands[no];
 
                 if (calleeData.signature.at(no) == INTR_ONLY){
                     sig.bindings.push_back(process(op));
                     continue;
                 }
 
                 argsActual.push_back(scopeUnitSelf->process(op));
             }
 
             TargetInterpretation* man = dynamic_cast<TargetInterpretation*>(this->function->man);
             PIFunction* pifunction =  man->getFunction(move(sig));
 
             llvm::Function* raw = pifunction->compile();
             boost::scoped_ptr<CallStatementRaw> statement(new CallStatementRaw(raw, man->pass->man->llvm));
             return (*statement)(move(argsActual));
         }
 
         default: break;
     }
 
     assert(false&& "Unknown hybrid operator");
     return nullptr;
 }
 
 llvm::Value*
 InterpretationScope::compile(const Expression& expression, const Context& context){
     const InterpretationData& data = Attachments::get<InterpretationData>(expression);
 
     if (data.op != InterpretationOperator::NONE){
         return compileHybrid(data.op, expression, context);
     }
 
     Expression result = process(expression);
     return context.scope->process(result);
 }
 
 Expression
 InterpretationScope::process(const Expression& expression){
     switch (expression.__state){
         case Expression::INVALID:
             assert(false);
 
         case Expression::VARIANT:
         case Expression::NUMBER:
         case Expression::STRING:
             return expression;
 
         case Expression::IDENT:{
             Symbol s = Attachments::get<Symbol>(expression);
             return Parent::processSymbol(s);
         }
 
         case Expression::COMPOUND:
             break;
 
         default: assert(false);
     }
 
     switch (expression.op) {
         case Operator::EQU: {
             const Expression& left = process(expression.operands[0]);
             const Expression& right = process(expression.operands[1]);
 
             if (left == right) return EXPRESSION_TRUE;
             return EXPRESSION_FALSE;
         }
 
         case Operator::NE: {
             const Expression& left = process(expression.operands[0]);
             const Expression& right = process(expression.operands[1]);
 
             if (left == right) return EXPRESSION_FALSE;
             return EXPRESSION_TRUE;
         }
 
         case Operator::LOGIC_AND: {
             assert(expression.operands.size() == 1);
             return process (expression.operands[0]);
         }
 
 
 //        case Operator::LOGIC_OR:
         case Operator::CALL: {
             const std::string &fnName = expression.getValueString();
             ManagedFnPtr fnAst = this->function->man->ast->findFunction(fnName);
             InterpretationFunction* fnUnit = this->function->man->getFunction(fnAst);
 
             vector<Expression> args;
             args.reserve(expression.getOperands().size());
 
             for(size_t i=0, size = expression.getOperands().size(); i<size; ++i) {
                 args.push_back(process(expression.getOperands()[i]));
             }
 
             return fnUnit->process(args);
         }
 
         case Operator::IF:{
             CodeScope* scopeResult = processOperatorIf(expression);
             return function->getScope(scopeResult)->processScope();
         }
 
         case Operator::SWITCH: {
             CodeScope* scopeResult = processOperatorSwitch(expression);
             return function->getScope(scopeResult)->processScope();
         }
 
         case Operator::INDEX: {
             const Expression& exprKey = process(expression.operands[1]);
             const Expression& exprData = process(expression.operands[0]);
 
             if (exprKey.__state == Expression::STRING){
                 const string& key = exprKey.getValueString();
                 assert(exprData.__indexBindings.count(key));
 
                 return exprData.operands[exprData.__indexBindings.at(key)];
             }
 
             if (exprKey.__state == Expression::NUMBER){
                 int key = exprKey.getValueDouble();
                 return exprData.operands[key];
             }
 
             assert(false);
         }
 
         case Operator::FOLD: {
             const Expression& exprInput = process(expression.getOperands()[0]);
             const Expression& exprInit = process(expression.getOperands()[1]);
 
             const std::string& argEl = expression.bindings[0];
             const std::string& argAccum = expression.bindings[1];
 
             InterpretationScope* body = function->getScope(expression.blocks.front());
 
             Expression accum = exprInit;
             for(size_t size=exprInput.getOperands().size(), i=0; i<size; ++i){
                 body->overrideBinding(exprInput.getOperands()[i], argEl);
                 body->overrideBinding(accum, argAccum);
 
                 accum = body->processScope();
             }
 
             return accum;
         }
 
 //        case Operator::MAP: {
 //            break;
 //        }
 
         default: break;
     }
 
     return expression;
 }
 
 InterpretationFunction*
 TargetInterpretation::getFunction(FunctionUnit* unit){
     if (__dictFunctionsByUnit.count(unit)) {
         return __dictFunctionsByUnit.at(unit);
     }
 
     InterpretationFunction* f = new InterpretationFunction(unit->function, this);
     __dictFunctionsByUnit.emplace(unit, f);
     assert(__functions.emplace(unit->function.id(), f).second);
 
     return f;
 }
 
 PIFunction*
 TargetInterpretation::getFunction(PIFSignature&& sig){
 
     auto f = __pifunctions.find(sig);
     if (f != __pifunctions.end()){
         return f->second;
     }
 
     PIFunction* result  = new PIFunction(PIFSignature(sig), __pifunctions.size(), this);
     __pifunctions.emplace(move(sig), result);
     assert(__dictFunctionsByUnit.emplace(result->functionUnit, result).second);
 
     return result;
 }
 
 InterpretationScope*
 TargetInterpretation::transformContext(const Context& c){
     return this->getFunction(c.function)->getScope(c.scope->scope);
 }
 
 llvm::Value*
 TargetInterpretation::compile(const Expression& expression, const Context& ctx){
     return transformContext(ctx)->compile(expression, ctx);
 }
 
 InterpretationFunction::InterpretationFunction(const ManagedFnPtr& function, Target<TargetInterpretation>* target)
     : Function<TargetInterpretation>(function, target)
 {}
 
 Expression
 InterpretationFunction::process(const std::vector<Expression>& args){
     InterpretationScope* body = getScope(__function->__entry);
 
     for(size_t i=0, size = args.size(); i<size; ++i) {
         body->overrideBinding(args.at(i), string(body->scope->__bindings.at(i)));
     }
 
     return body->processScope();
 }
 
 //                  Partial function interpretation
 
 typedef BasicFunctionDecorator PIFunctionUnitParent;
 class PIFunctionUnit: public PIFunctionUnitParent{
 public:
 
     PIFunctionUnit(ManagedFnPtr f, std::set<size_t>&& arguments, size_t id, CompilePass* p)
         : PIFunctionUnitParent(f,  p), argumentsActual(move(arguments)), __id(id)
     {}
 
 protected:
     std::vector<llvm::Type*> prepareArguments(){
         LLVMLayer* llvm = PIFunctionUnitParent::pass->man->llvm;
         AST* ast = PIFunctionUnitParent::pass->man->root;
         CodeScope* entry = PIFunctionUnitParent::function->__entry;
         std::vector<llvm::Type*> signature;
 
         for(size_t no: argumentsActual){
             VNameId argId = entry->__identifiers.at(entry->__bindings.at(no));
             ScopedSymbol arg{argId, VERSION_NONE};
 
             signature.push_back(llvm->toLLVMType(ast->expandType(entry->__declarations.at(arg).type)));
         }
 
         return signature;
     }
 
     llvm::Function::arg_iterator prepareBindings(){
         CodeScope* entry = PIFunctionUnitParent::function->__entry;
         AbstractCodeScopeUnit* entryCompilation = PIFunctionUnitParent::getScopeUnit(entry);
         llvm::Function::arg_iterator fargsI = PIFunctionUnitParent::raw->arg_begin();
 
         for(size_t no: argumentsActual){
             ScopedSymbol arg{entry->__identifiers.at(entry->__bindings.at(no)), VERSION_NONE};
 
             entryCompilation->bindArg(&*fargsI, arg);
             fargsI->setName(entry->__bindings.at(no));
             ++fargsI;
         }
 
         return fargsI;
     }
 
     virtual std::string prepareName(){
         return PIFunctionUnitParent::prepareName() + "_" + std::to_string(__id);
     }
 
 private:
     std::set<size_t> argumentsActual;
     size_t __id;
 };
 
 PIFunction::PIFunction(PIFSignature&& sig, size_t id, TargetInterpretation* target)
     : InterpretationFunction(sig.declaration, target), signatureInstance(move(sig))
 {
     const FunctionInterpretationData&  functionData = FunctionInterpretationHelper::getSignature(signatureInstance.declaration);
 
     std::set<size_t> argumentsActual;
     for (size_t no=0, size=functionData.signature.size(); no < size; ++no){
         if (functionData.signature.at(no) != INTR_ONLY){
             argumentsActual.insert(no);
         }
     }
 
     functionUnit = new PIFunctionUnit(signatureInstance.declaration, move(argumentsActual), id, target->pass);
     CodeScope* entry = signatureInstance.declaration->__entry;
     auto entryUnit = Decorators<CachedScopeDecoratorTag>::getInterface<>(functionUnit->getEntry());
     InterpretationScope* entryIntrp = InterpretationFunction::getScope(entry);
 
     for(size_t no=0, sigNo=0, size = entry->__bindings.size(); no < size; ++no){
         if (functionData.signature.at(no) == INTR_ONLY){
             entryIntrp->overrideBinding(signatureInstance.bindings[sigNo], entry->__bindings[no]);
 
             VNameId argId = entry->__identifiers.at(entry->__bindings[no]);
             Symbol argSymbol{ScopedSymbol{argId, VERSION_NONE}, entry};
             entryUnit->overrideDeclaration(argSymbol, Expression(signatureInstance.bindings[sigNo]));
             ++sigNo;
         }
     }
 }
 
 llvm::Function*
 PIFunction::compile(){
     llvm::Function* raw = functionUnit->compile();
 
     return raw;
 }
 
 bool operator<(const PIFSignature& lhs, const PIFSignature& rhs){
     if (lhs.declaration.id() != rhs.declaration.id()) {
         return lhs.declaration.id() < rhs.declaration.id();
     }
 
     return lhs.bindings < rhs.bindings;
 }
 
 bool operator<(const PIFSignature& lhs, PIFunction* const rhs){
     return lhs < rhs->signatureInstance;
 }
 
 bool operator<(PIFunction* const lhs, const PIFSignature& rhs){
     return lhs->signatureInstance < rhs;
 }
 
-}}
\ No newline at end of file
+}}
diff --git a/cpp/src/compilation/targets.h b/cpp/src/compilation/targets.h
index a871d44..2ec48eb 100644
--- a/cpp/src/compilation/targets.h
+++ b/cpp/src/compilation/targets.h
@@ -1,161 +1,191 @@
 /* 
  * File:   targetabstract.h
  * Author: pgess
  *
  * Created on July 2, 2016, 1:25 PM
  */
 
 #ifndef TARGETABSTRACT_H
 #define TARGETABSTRACT_H
 #include "ast.h"
 
 #include <boost/optional.hpp>
 #include <map>
 
 namespace xreate{ namespace compilation {
     
 template <typename ConcreteTarget> 
 struct TargetInfo{
     //typedef Result 
     //typedef Function
     //typedef Scope 
 };
     
 template<typename ConcreteTarget>
 class Function;
 
 template<typename ConcreteTarget>
 class Target;
 
 template<typename ConcreteTarget>
 class Scope{
+    typedef typename TargetInfo<ConcreteTarget>::Scope Self;
+    
 public:
     CodeScope* scope;
     
     typename TargetInfo<ConcreteTarget>::Result
     processSymbol(const Symbol& s){
         CodeScope* scope = s.scope;
-        typename TargetInfo<ConcreteTarget>::Scope* self = function->getScope(scope);
+        Self* self = function->getScope(scope);
 
         if (self->__bindings.count(s.identifier))     {
             return self->__bindings[s.identifier];
         }
 
         const Expression& declaration = CodeScope::getDeclaration(s);
         if (!declaration.isDefined()){
             assert(false); //for bindings there should be result already
         }
         
         return self->__bindings[s.identifier] = self->process(declaration);
     }
     
     typename TargetInfo<ConcreteTarget>::Result
     processScope() {
         if (raw) return *raw;
 
         raw = process(scope->getBody());
         return *raw;
     }
     
 //    typename TargetInfo<ConcreteTarget>::Result
 //    processFunction(typename TargetInfo<ConcreteTarget>::Function* fnRemote, const std::vector<typename TargetInfo<ConcreteTarget>::Result>& args){
 //        Scope<ConcreteTarget> scopeRemote = fnRemote->getScope(fnRemote->__function->__entry);
 //        
 //        if (scopeRemote->raw){
 //            return scopeRemote->raw;
 //        }
 //        
 //        return fnRemote->process(args);
 //    }
     
     virtual typename TargetInfo<ConcreteTarget>::Result
     process(const Expression& expression)=0;    
     
     Scope(CodeScope* codeScope, Function<ConcreteTarget>* f)
             : scope(codeScope), function(f)  {}
     
     virtual ~Scope(){}
 
     void 
     overrideBinding(typename TargetInfo<ConcreteTarget>::Result arg, const std::string& name){
         assert(scope->__identifiers.count(name));
         
         ScopedSymbol id{scope->__identifiers.at(name), VERSION_NONE};
         __bindings[id] = arg;
         
         //reset the result if any:
         raw.reset();
     }
     
+    void registerChildScope(std::shared_ptr<Self> scope){
+        __childScopes.push_back(scope);
+    }
+
+    void reset(){
+        __bindings.clear();
+        __childScopes.clear();
+        raw == nullptr;
+    }
+    
 protected:
     Function<ConcreteTarget>* function=0;
     std::map<ScopedSymbol, typename TargetInfo<ConcreteTarget>::Result> __bindings;
+    std::list<std::shared_ptr<Self>> __childScopes;
     typename boost::optional<typename TargetInfo<ConcreteTarget>::Result> raw;
-    
-    //ResultType findFunction(const std::string& callee);
 };
 
 template<typename ConcreteTarget>
 class Function{
     typedef typename TargetInfo<ConcreteTarget>::Result Result;
+    typedef typename TargetInfo<ConcreteTarget>::Scope ConcreteScope;
     
 public:
     Function(const ManagedFnPtr& function, Target<ConcreteTarget>* target)
         : man(target), __function(function)  {}
         
 	virtual ~Function(){};
         
-    typename TargetInfo<ConcreteTarget>::Scope*
+    ConcreteScope*
     getScope(CodeScope* scope){
-        if (!__scopes.count(scope)){
-            typename TargetInfo<ConcreteTarget>::Scope* unit = new typename TargetInfo<ConcreteTarget>::Scope(scope, this);
-            __scopes.emplace(scope, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>(unit));
+        if (__scopes.count(scope)) {
+            auto result = __scopes.at(scope).lock();
+            
+            if (result){
+                return result.get();
+            }
+        }
+
+        std::shared_ptr<ConcreteScope> unit(new ConcreteScope(scope, this));
+            
+        if (scope->__parent != nullptr){
+            getScope(scope->__parent)->registerChildScope(unit);
+
+        } else {
+            assert(!__entryScope);
+            __entryScope = unit;
         }
 
-        return __scopes.at(scope).get();
+        if (!__scopes.emplace(scope, unit).second){
+            __scopes[scope] = unit;
+        }
+        
+        return unit.get();
     }
     
     virtual Result
     process(const std::vector<Result>& args)=0;
     
     Target<ConcreteTarget>* man=0;
     ManagedFnPtr __function;
 
 protected:
-    std::map<CodeScope*, std::unique_ptr<typename TargetInfo<ConcreteTarget>::Scope>> __scopes;
+    std::map<CodeScope*, std::weak_ptr<ConcreteScope>> __scopes;
+    std::shared_ptr<ConcreteScope> __entryScope;
 };
 
 template<typename ConcreteTarget>
 class Target {
     typedef typename TargetInfo<ConcreteTarget>::Function ConcreteFunction;
     
     public:
         Target(AST* root): ast(root){}
         
         ConcreteFunction*
         getFunction(const ManagedFnPtr& function){
             unsigned int id = function.id();
 
             if (!__functions.count(id)){
                 ConcreteFunction* unit = new ConcreteFunction(function, this);
                 __functions.emplace(id, unit);
                 return unit;
             }
 
             return __functions.at(id);
         }
         
         AST* ast;
         virtual ~Target(){
             for (const auto& entry: __functions){
                 delete entry.second;
             }
         }
         
     protected:
         std::map<unsigned int, ConcreteFunction*> __functions;
 };
 
 }}
 
-#endif /* TARGETABSTRACT_H */
\ No newline at end of file
+#endif /* TARGETABSTRACT_H */
diff --git a/cpp/src/compilation/transformations.h b/cpp/src/compilation/transformations.h
index 4350147..d2ac123 100644
--- a/cpp/src/compilation/transformations.h
+++ b/cpp/src/compilation/transformations.h
@@ -1,111 +1,110 @@
 /* 
  * File:   transformations.h
  * Author: pgess <v.melnychenko@xreate.org>
  *
  * Created on March 25, 2017, 9:04 PM
  */
 
 #ifndef TRANSFORMATIONS_H
 #define TRANSFORMATIONS_H
 
 #include "pass/compilepass.h"
 
 namespace xreate {    namespace compilation {
 
 template <class TransformerType> 
 struct TransformerInfo {
     //static const unsigned int id = 1; (current vacant id)
 };
     
 class Transformer{
 public:
     virtual llvm::Value* transform(const Expression& expression, llvm::Value* raw, const Context& ctx)=0;
     virtual ~Transformer(){};
 };
 
 class TransformationsManager {
 public:
     std::list<Transformer*> getRelevantTransformers(const Expression& expression);
     
     
     template<class TransformerType>
     void registerTransformer(const std::string& annotation, TransformerType* t){
         const int id = TransformerInfo<TransformerType>::id;
 
         assert(!__transformers.count(id));
         __transformers[id] = t;
         __subscriptions.emplace(annotation, id);
     }
     
     template<class TransformerType>
     void unregisterTransformer(const std::string& annotation, TransformerType* t){
         const unsigned int id = TransformerInfo<TransformerType>::id;
 
         auto range = __subscriptions.equal_range(annotation);
         const auto entry = make_pair(annotation, id);
         __subscriptions.erase(std::find_if(range.first, range.second, [id](const auto& el){return el.second == id;}));
         __transformers.erase(id);
     }
     
     template<class TransformerType>
     TransformerType* update(TransformerType* newInstance){
         const int id = TransformerInfo<TransformerType>::id;
         
         Transformer* oldInstance = __transformers[id];
         __transformers[id] = newInstance;
         
         return static_cast<TransformerType*>(oldInstance);
     }
     
     template<class TransformerType>
     bool exists(){
         const int id = TransformerInfo<TransformerType>::id;
         
         return __transformers.count(id);
     }
             
     template <class TransformerType>
     TransformerType* get(){
         const int id = TransformerInfo<TransformerType>::id;
         return static_cast<TransformerType*>(__transformers.at(id));
     }    
     
 private:
     std::map<unsigned int, Transformer*> __transformers;
     std::multimap<std::string, unsigned int> __subscriptions;
 };
 
 template <class Parent>
 class TransformationsScopeDecorator: public Transformer, public Parent {
                 // SCOPE DECORATOR PART
 public:    
     TransformationsScopeDecorator(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass)
         : Parent(codeScope, f, compilePass){}
     
     virtual llvm::Value* 
     process(const Expression& expr, const std::string& hintVarDecl=""){
         llvm::Value* result = Parent::process(expr, hintVarDecl);
-
         return transform(expr, result, Context{this, Parent::function, Parent::pass});
     }
   
                 // TRANSFORMER PART
 public:
     virtual llvm::Value* 
     transform(const Expression& expression, llvm::Value* raw, const Context& ctx) {
         llvm::Value* result = raw;
         TransformationsManager* man = Parent::pass->managerTransformations;
         
         if (expression.tags.size())
         for (Transformer* handler: man->getRelevantTransformers(expression)){
             result = handler->transform(expression, result, ctx);
         }
         
         return result;
     }
 };
     
 } } 
 
 #endif /* TRANSFORMATIONS_H */
 
diff --git a/cpp/src/llvmlayer.cpp b/cpp/src/llvmlayer.cpp
index ca7ce01..2d9cce1 100644
--- a/cpp/src/llvmlayer.cpp
+++ b/cpp/src/llvmlayer.cpp
@@ -1,255 +1,258 @@
 #include "ast.h"
 #include "llvmlayer.h"
 #include "ExternLayer.h"
 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/ExecutionEngine/MCJIT.h"
 #include "llvm/Support/TargetSelect.h"
 #include <iostream>
 #include <cmath>
 
 using namespace llvm;
 using namespace xreate;
 using namespace std;
 
 LLVMLayer::LLVMLayer(AST* root)
     : ast(root), builder(getGlobalContext()) {
     module = new llvm::Module(root->getModuleName(), llvm::getGlobalContext());
     layerExtern = new ExternLayer(this);
     layerExtern->init(root);
 }
 
 void*
 LLVMLayer::getFunctionPointer(llvm::Function* function){
 	uint64_t entryAddr = jit->getFunctionAddress(function->getName().str());
 	return (void*) entryAddr;
 }
 
 void
 LLVMLayer::initJit(){
 	std::string ErrStr;
 	LLVMInitializeNativeTarget();
 	llvm::InitializeNativeTargetAsmPrinter();
 
 	llvm::EngineBuilder builder((std::unique_ptr<llvm::Module>(module)));
 	jit = builder
 		.setEngineKind(llvm::EngineKind::JIT)
 		.setErrorStr(&ErrStr)
 		.setVerifyModules(true)
 		.create();
 }
 
 void
 LLVMLayer::print(){
     llvm::PassManager<llvm::Module> PM;
     PM.addPass(llvm::PrintModulePass(llvm::outs(), "banner"));
     PM.run(*module);
 }
 
 llvm::BasicBlock*
 LLVMLayer::initExceptionBlock(llvm::BasicBlock* blockException){
 	initExceptionsSupport();
 
 	PointerType* tyInt8P = PointerType::getInt8PtrTy(llvm::getGlobalContext());
     Value* nullInt8P = llvm::ConstantPointerNull::get(tyInt8P);
 
 
 	builder.SetInsertPoint(blockException);
 	llvm::Function* fAllocate = module->getFunction("__cxa_allocate_exception");
 	llvm::Function* fThrow = module->getFunction("__cxa_throw");
 
 	auto exception = builder.CreateCall(fAllocate, ConstantInt::get(IntegerType::getInt64Ty(getGlobalContext()), 4));
 	vector<Value*> throwParams{exception, nullInt8P, nullInt8P};
 	builder.CreateCall(fThrow, ArrayRef<Value*>(throwParams));
 	builder.CreateUnreachable();
 
 	return blockException;
 }
 
 void
 LLVMLayer::moveToGarbage(void *o)
 {
     __garbage.push_back(o);
 }
 
 llvm::Type*
 LLVMLayer::
 toLLVMType(const ExpandedType& ty) const {
 	std::map<int, llvm::StructType*> empty;
 	return toLLVMType(ty, empty);
 }
 
 llvm::Type*
 LLVMLayer::
 toLLVMType(const ExpandedType& ty, std::map<int, llvm::StructType*>& conjuctions) const
 {
     TypeAnnotation t = ty;
     switch (t.__operator)
     {
         case TypeOperator::ARRAY:
         {
             assert(t.__operands.size()==1);
 
             TypeAnnotation elTy = t.__operands.at(0);
             return llvm::ArrayType::get(toLLVMType(ExpandedType(move(elTy)), conjuctions), t.__size);
         }
 
         case TypeOperator::STRUCT:
         case TypeOperator::TUPLE:
         {
             assert(t.__operands.size());
 
             std::vector<llvm::Type*> pack_;
             pack_.reserve(t.__operands.size());
 
             std::transform(t.__operands.begin(), t.__operands.end(), std::inserter(pack_, pack_.end()),
 			   [this, &conjuctions](const TypeAnnotation& t){
 				   return toLLVMType(ExpandedType(TypeAnnotation(t)), conjuctions);
 			   });
 
             llvm::ArrayRef<llvm::Type*> pack(pack_);
 
             			//process recursive types:
             if (conjuctions.count(t.conjuctionId)) {
             	auto result = conjuctions[t.conjuctionId];
             	result->setBody(pack, false);
 
             	return result;
             }
 
             return llvm::StructType::get(llvm::getGlobalContext(), pack, false);
         };
 
         case TypeOperator::LINK: {
         	llvm::StructType* conjuction = llvm::StructType::create(llvm::getGlobalContext());
         	int id = t.conjuctionId;
 
         	conjuctions.emplace(id, conjuction);
         	return conjuction;
         };
 
         case TypeOperator::CALL:
         {
             assert(false);
         };
 
         case TypeOperator::CUSTOM:
         {
             //Look in extern types
 
             clang::QualType qt = layerExtern->lookupType(t.__valueCustom);
             return layerExtern->toLLVMType(qt);
         };
 
         case TypeOperator::VARIANT: {
         	int size = t.fields.size();
         	assert(size);
 
         	int bitcount = ceil(log2(size));
         	return llvm::Type::getIntNTy(llvm::getGlobalContext(), bitcount);
         }
 
         case TypeOperator::NONE: {
             switch (t.__value) {
-                case TypePrimitive::Bool:
-                    return llvm::Type::getInt1Ty(llvm::getGlobalContext());
-
                 case TypePrimitive::I32:
                 case TypePrimitive::Int:
                 case TypePrimitive::Num:
                     return llvm::Type::getInt32Ty(llvm::getGlobalContext());
 
+                case TypePrimitive::Bool:
+                    return llvm::Type::getInt1Ty(llvm::getGlobalContext());
+
                 case TypePrimitive::I8:
                     return llvm::Type::getInt8Ty(llvm::getGlobalContext());
 
+                case TypePrimitive::I64:
+                    return llvm::Type::getInt64Ty(llvm::getGlobalContext());
+
                 case TypePrimitive::Float:
                     return llvm::Type::getDoubleTy(llvm::getGlobalContext());
 
                 case TypePrimitive::String:
                     return llvm::Type::getInt8PtrTy(llvm::getGlobalContext());
 
                 default:
                     assert(false);
             }
         }
 
         default:
             assert(false);
     }
 
     assert(false);
     return  nullptr;
 }
 
 void
 LLVMLayer::initExceptionsSupport(){
 	Type* typInt8Ptr = PointerType::get(IntegerType::get(module->getContext(), 8), 0);
 
 	if (!module->getFunction("__cxa_throw")) {
 		std::vector<Type*>	fThrowSignature{typInt8Ptr, typInt8Ptr, typInt8Ptr};
 
 		 FunctionType* tyFThrow = FunctionType::get(
 		  /*Result=*/Type::getVoidTy(module->getContext()),
 		  /*Params=*/fThrowSignature,
 		  /*isVarArg=*/false);
 
 		llvm::Function::Create(
 	 /*Type=*/tyFThrow,
 	 /*Linkage=*/GlobalValue::ExternalLinkage,
 	 /*Name=*/"__cxa_throw", module); // (external, no body)
 	}
 
 	if (!module->getFunction("__cxa_allocate_exception")) {
 		 std::vector<Type*>fAllocateSignature{IntegerType::get(module->getContext(), 64)};
 
 		 FunctionType* tyFAllocate = FunctionType::get(
 		  /*Result=*/typInt8Ptr,
 		  /*Params=*/fAllocateSignature,
 		  /*isVarArg=*/false);
 
 		llvm::Function::Create(
 	 /*Type=*/tyFAllocate,
 	 /*Linkage=*/GlobalValue::ExternalLinkage,
 	 /*Name=*/"__cxa_allocate_exception", module); // (external, no body)
 	}
 }
 
 bool TypeUtils::isStruct(const ExpandedType& ty){
     const TypeAnnotation& t = ty.get();
 
     if (t.__operator==TypeOperator::STRUCT) {
         return true;
     }
 
     if (t.__operator != TypeOperator::CUSTOM) {
         return false;
     }
 
     clang::QualType tqual = llvm->layerExtern->lookupType(t.__valueCustom);
     const clang::Type * raw = tqual.getTypePtr();
 
         // TODO skip ALL the pointers until non-pointer type found
     if (raw->isStructureType()) return true;
     if (!raw->isAnyPointerType()) return false;
 
     clang::QualType pointee = raw->getPointeeType();
     return pointee->isStructureType();
 }
 
 
 bool TypeUtils::isPointer(const ExpandedType &ty) {
     if (ty.get().__operator != TypeOperator::CUSTOM) return false;
 
     clang::QualType qt = llvm->layerExtern->lookupType(ty.get().__valueCustom);
     return llvm->layerExtern->isPointer(qt);
 }
 
 
 std::vector<std::string>
 TypeUtils::getStructFields(const ExpandedType &t) {
     return (t.get().__operator == TypeOperator::STRUCT)
            ? t.get().fields
             : llvm->layerExtern->getStructFields(
                     llvm->layerExtern->lookupType(t.get().__valueCustom));
 }
 
 
diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
index b1967c8..e9e7d12 100644
--- a/cpp/src/pass/compilepass.cpp
+++ b/cpp/src/pass/compilepass.cpp
@@ -1,765 +1,799 @@
 #include "compilepass.h"
 #include "clasplayer.h"
 #include <ast.h>
 #include "llvmlayer.h"
 
 #include "query/containers.h"
 #include "query/context.h"
 #include "compilation/containers.h"
 #include "compilation/latecontextcompiler2.h"
 #include "ExternLayer.h"
 #include "pass/adhocpass.h"
 #include "compilation/targetinterpretation.h"
 #include "pass/versionspass.h"
 #include "compilation/scopedecorators.h"
+#include "compilation/pointerarithmetic.h"
 
 #include <boost/optional.hpp>
 #include <memory>
 #include <iostream>
 
 using namespace std;
 using namespace xreate;
 using namespace xreate::compilation;
 using namespace llvm;
 
 //TODO use Scope<TargetLlvm>
 
 //SECTIONTAG types/convert implementation
 //TODO type conversion:
 //a)    automatically expand types int -> bigger int; int -> floating
 //b)    detect exact type of `num` based on max used numeral / function type
 //c)    warning if need to truncate (allow/dissalow based on annotations)
 
 namespace xreate {
 
 llvm::Value*
 doAutomaticTypeConversion(llvm::Value* source, llvm::Type* tyTarget, llvm::IRBuilder<>& builder){
     if (tyTarget->isIntegerTy() && source->getType()->isIntegerTy())
     {
             llvm::IntegerType* tyTargetInt = llvm::dyn_cast<IntegerType>(tyTarget);
             llvm::IntegerType* tySourceInt = llvm::dyn_cast<IntegerType>(source->getType());
 
             if (tyTargetInt->getBitWidth() < tySourceInt->getBitWidth()){
                     return builder.CreateCast(llvm::Instruction::Trunc, source, tyTarget);
             }
 
             if (tyTargetInt->getBitWidth() > tySourceInt->getBitWidth()){
                     return builder.CreateCast(llvm::Instruction::SExt, source, tyTarget);
             }
     }
 
     if (source->getType()->isIntegerTy() && tyTarget->isFloatingPointTy()){
         return builder.CreateCast(llvm::Instruction::SIToFP, source, tyTarget);
     }
 
     return source;
 }
 
 
 std::string
 BasicFunctionDecorator::prepareName(){
     AST* ast = FunctionUnit::pass->man->root;
 
     string name = ast->getFunctionVariants(FunctionUnit::function->__name).size() > 1?
         FunctionUnit::function->__name  + std::to_string(FunctionUnit::function.id()) :
         FunctionUnit::function->__name;
 
     return name;
 }
 
 std::vector<llvm::Type*>
 BasicFunctionDecorator::prepareArguments(){
     LLVMLayer* llvm = FunctionUnit::pass->man->llvm;
     AST* ast = FunctionUnit::pass->man->root;
     CodeScope* entry = FunctionUnit::function->__entry;
     std::vector<llvm::Type*> signature;
 
     std::transform(entry->__bindings.begin(), entry->__bindings.end(), std::inserter(signature, signature.end()),
             [llvm, ast, entry](const std::string &arg)->llvm::Type* {
                 assert(entry->__identifiers.count(arg));
 
                 ScopedSymbol argid{entry->__identifiers.at(arg), VERSION_NONE};
                 return llvm->toLLVMType(ast->expandType(entry->__declarations.at(argid).type));
     });
 
     return signature;
 }
 
 llvm::Type*
 BasicFunctionDecorator::prepareResult(){
     LLVMLayer* llvm = FunctionUnit::pass->man->llvm;
     AST* ast = FunctionUnit::pass->man->root;
     CodeScope* entry = FunctionUnit::function->__entry;
 
     return llvm->toLLVMType(ast->expandType(entry->__declarations.at(ScopedSymbol::RetSymbol).type));
 }
 
 llvm::Function::arg_iterator
 BasicFunctionDecorator::prepareBindings(){
     CodeScope* entry = FunctionUnit::function->__entry;
     AbstractCodeScopeUnit* entryCompilation = FunctionUnit::getScopeUnit(entry);
     llvm::Function::arg_iterator fargsI = FunctionUnit::raw->arg_begin();
 
     for (std::string &arg : entry->__bindings) {
         ScopedSymbol argid{entry->__identifiers[arg], VERSION_NONE};
 
         entryCompilation->bindArg(&*fargsI, argid);
         fargsI->setName(arg);
         ++fargsI;
     }
 
     return fargsI;
 }
 
 //SECTIONTAG late-context FunctionDecorator
 template<class Parent>
 class LateContextFunctionDecorator: public Parent{
 public:
     LateContextFunctionDecorator(ManagedFnPtr f, CompilePass* p)
         : Parent(f, p), contextCompiler(this, p)
     {}
 
 protected:
     std::vector<llvm::Type*>  prepareArguments(){
         std::vector<llvm::Type*>&& arguments = Parent::prepareArguments();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand) {
             llvm::Type* ty32 = llvm::Type::getInt32Ty(llvm::getGlobalContext());
             llvm::Type* tyDemand = llvm::ArrayType::get(ty32, sizeLateContextDemand);
 
             arguments.push_back(tyDemand);
         }
 
         return arguments;
     }
 
     llvm::Function::arg_iterator prepareBindings(){
         llvm::Function::arg_iterator fargsI = Parent::prepareBindings();
 
         size_t sizeLateContextDemand = contextCompiler.getFunctionDemandSize();
         if (sizeLateContextDemand){
             fargsI->setName("latecontext");
             contextCompiler.rawContextArgument = &*fargsI;
             ++fargsI;
         }
 
         return fargsI;
     }
 
 public:
     LateContextCompiler2 contextCompiler;
 
 };
 
 //SECTIONTAG adhoc FunctionDecorator
 template<class Parent>
 class AdhocFunctionDecorator: public Parent{
 public:
     AdhocFunctionDecorator(ManagedFnPtr f, CompilePass* p)
         : Parent(f, p)    {}
 
 protected:
     llvm::Type* prepareResult(){
         PassManager* man = Parent::pass->man;
         CodeScope* entry = Parent::function->__entry;
         LLVMLayer* llvm = Parent::pass->man->llvm;
         AST* ast = Parent::pass->man->root;
         AdhocPass* adhocpass = reinterpret_cast<AdhocPass*>(man->getPassById(PassId::AdhocPass));
 
         if (! Parent::function->isPrefunction){
             return Parent::prepareResult();
         }
 
         adhocImplementation = adhocpass->findAssotiatedScheme(entry);
         return llvm->toLLVMType(ast->expandType(adhocImplementation->getResultType()));
     }
 
 public:
     AdhocScheme* adhocImplementation=nullptr;
 
 };
 
 //DEBT compiler rigidly depends on exact definition of DefaultFunctionUnit
 typedef LateContextFunctionDecorator<
         AdhocFunctionDecorator<
         BasicFunctionDecorator>> DefaultFunctionUnit;
 
 
 AbstractCodeScopeUnit::AbstractCodeScopeUnit(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass)
     : pass(compilePass), function(f), scope(codeScope)
 {}
 
 
 llvm::Value*
 CallStatementRaw::operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
     llvm::Function* calleeInfo = dyn_cast<llvm::Function>(__callee);
 
     if (calleeInfo){
         auto argsFormal = calleeInfo->args();
 
         int pos=0;
         //SECTIONTAG types/convert function ret value
         for (auto argFormal = argsFormal.begin(); argFormal!=argsFormal.end(); ++argFormal, ++pos){
             args[pos] = doAutomaticTypeConversion(args[pos], argFormal->getType(), llvm->builder);
         }
     }
 
     return llvm->builder.CreateCall(__calleeTy, __callee, args, hintDecl);
 }
 
 //DESABLEDFEATURE implement inlining
 class CallStatementInline: public CallStatement{
 public:
 	CallStatementInline(FunctionUnit* caller, FunctionUnit* callee, LLVMLayer* l)
 		: __caller(caller), __callee(callee), llvm(l) {}
 
 	llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl) {
 		//TOTEST inlining
 //            CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
 //            for(int i=0, size = args.size(); i<size; ++i) {
 //                entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__bindings.at(i)));
 //            }
 //
 //
 //            return entryCompilation->compile();
 
             return nullptr;
 	}
 
 private:
 	FunctionUnit* __caller;
 	FunctionUnit* __callee;
         LLVMLayer* llvm;
 
         bool isInline(){
             // Symbol ret = Symbol{0, function->__entry};
             // bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
             //TODO consider inlining
             return false;
         }
 };
 
 }
 
 BasicCodeScopeUnit::BasicCodeScopeUnit(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass)
     : AbstractCodeScopeUnit(codeScope, f, compilePass)
 {}
 
 llvm::Value*
 BasicCodeScopeUnit::processSymbol(const Symbol& s, std::string hintRetVar){
     Expression declaration = CodeScope::getDeclaration(s);
     CodeScope* scope = s.scope;
     AbstractCodeScopeUnit* self = AbstractCodeScopeUnit::function->getScopeUnit(scope);
 
     return self->process(declaration, hintRetVar);
 }
 
 
 //SECTIONTAG late-context find callee function
 //TOTEST static late context decisions
 //TOTEST dynamic late context decisions
 CallStatement*
 BasicCodeScopeUnit::findFunction(const std::string& calleeName){
     LLVMLayer* llvm = pass->man->llvm;
     ClaspLayer* clasp = pass->man->clasp;
     DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*>(this->function);
     ContextQuery* queryContext = pass->queryContext;
 
     const std::list<ManagedFnPtr>& specializations = pass->man->root->getFunctionVariants(calleeName);
 
     //if no specializations registered - check external function
     if (specializations.size()==0){
         llvm::Function* external = llvm->layerExtern->lookupFunction(calleeName);
 
+        llvm::outs() << "Debug/External function: " << calleeName;
+        external->getType()->print(llvm::outs(), true);
+        llvm::outs() << "\n";
+
         return new CallStatementRaw(external, llvm);
     }
 
     //no decisions required
     if (specializations.size()==1){
         if (!specializations.front()->guardContext.isValid()) {
             return new CallStatementRaw( pass->getFunctionUnit(specializations.front())->compile(), llvm);
         }
     }
 
     //TODO move dictSpecialization over to a separate function in order to perform cache, etc.
     //prepare specializations dictionary
     std::map<Expression, ManagedFnPtr> dictSpecializations;
 
     boost::optional<ManagedFnPtr> variantDefault;
     boost::optional<ManagedFnPtr> variant;
 
     for(const ManagedFnPtr& f: specializations){
         const Expression& guard = f->guardContext;
 
         //default case:
         if (!guard.isValid()){
                 variantDefault = f;
                 continue;
         }
 
         assert(dictSpecializations.emplace(guard, f).second && "Found several identical specializations");
     }
 
     //check static context
     ScopePacked scopeCaller = clasp->pack(this->scope);
     const string atomSpecialization = "specialization";
     const Expression topicSpecialization(Operator::CALL, {(Atom<Identifier_t>(string(atomSpecialization))), (Atom<Identifier_t>(string(calleeName))), (Atom<Number_t>(scopeCaller))});
 
     const Decisions& decisions = queryContext->getFinalDecisions(scopeCaller);
     if (decisions.count(topicSpecialization)){
         variant =  dictSpecializations.at(decisions.at(topicSpecialization));
     }
 
     //TODO check only demand for this particular topic.
     size_t sizeDemand = function->contextCompiler.getFunctionDemandSize();
 
     //decision made if static context found or no late context exists(and there is default variant)
     bool flagHasStaticDecision =  variant || (variantDefault && !sizeDemand);
 
     //if no late context exists
     if (flagHasStaticDecision) {
         FunctionUnit* calleeUnit = pass->getFunctionUnit(variant? *variant: *variantDefault);
 
             //inlining possible based on static decision only
 //        if (calleeUnit->isInline()) {
 //            return new CallStatementInline(function, calleeUnit);
 //        }
 
         return new CallStatementRaw(calleeUnit->compile(), llvm);
     }
 
     //require default variant if no static decision made
     assert(variantDefault);
 
     llvm::Function* functionVariantDefault = this->pass->getFunctionUnit(*variantDefault)->compile();
     llvm::Value* resultFn = function->contextCompiler.findFunction(calleeName, functionVariantDefault, scopeCaller);
     llvm::PointerType *resultPTy = cast<llvm::PointerType>(resultFn->getType());
     llvm::FunctionType *resultFTy = cast<llvm::FunctionType>(resultPTy->getElementType());
     return new CallStatementRaw(resultFn, resultFTy, llvm);
 }
 
 
 
 //DISABLEDFEATURE transformations
 //    if (pass->transformations->isAcceptable(expr)){
 //        return pass->transformations->transform(expr, result, ctx);
 //    }
 
 llvm::Value*
 BasicCodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl){
 #define DEFAULT(x) (hintVarDecl.empty()? x: hintVarDecl)
     llvm::Value *left; llvm::Value *right;
     LLVMLayer& l = *pass->man->llvm;
     xreate::compilation::Advanced instructions = xreate::compilation::Advanced({this, function, pass});
 
     switch (expr.op) {
         case Operator::ADD: case Operator::SUB: case Operator::MUL:
         case Operator::DIV: case Operator::EQU: case Operator::LSS:
         case Operator::GTR: case Operator::NE:  case Operator::LSE:
         case Operator::GTE:
 
             assert(expr.__state == Expression::COMPOUND);
             assert(expr.operands.size() == 2);
 
             left = process(expr.operands[0]);
             right = process(expr.operands[1]);
 
             //SECTIONTAG types/convert binary operation
            	right =	doAutomaticTypeConversion(right, left->getType(), l.builder);
             break;
 
         default:;
     }
 
     switch (expr.op) {
-        case Operator::ADD:
+        case Operator::ADD:{
+            llvm::Value* resultAdd = PointerArithmetic::add(left, right, {this, function, pass}, DEFAULT("tmp_add"));
+            if (resultAdd) {return resultAdd;}
+
             return l.builder.CreateAdd(left, right, DEFAULT("tmp_add"));
             break;
+        }
 
         case Operator::SUB:
             return l.builder.CreateSub(left, right, DEFAULT("tmp_sub"));
             break;
 
         case Operator::MUL:
             return l.builder.CreateMul(left, right, DEFAULT("tmp_mul"));
             break;
 
         case Operator::DIV:
             return l.builder.CreateSDiv(left, right, DEFAULT("tmp_div"));
             break;
 
         case Operator::EQU:
             if (left->getType()->isIntegerTy()) return l.builder.CreateICmpEQ(left, right, DEFAULT("tmp_equ"));
             if (left->getType()->isFloatingPointTy()) return l.builder.CreateFCmpOEQ(left, right, DEFAULT("tmp_equ"));
             break;
 
         case Operator::NE:
             return l.builder.CreateICmpNE(left, right, DEFAULT("tmp_ne"));
             break;
 
         case Operator::LSS:
             return l.builder.CreateICmpSLT(left, right, DEFAULT("tmp_lss"));
             break;
 
         case Operator::LSE:
             return l.builder.CreateICmpSLE(left, right, DEFAULT("tmp_lse"));
             break;
 
         case Operator::GTR:
             return l.builder.CreateICmpSGT(left, right, DEFAULT("tmp_gtr"));
             break;
 
         case Operator::GTE:
             return l.builder.CreateICmpSGE(left, right, DEFAULT("tmp_gte"));
             break;
 
         case Operator::NEG:
             left = process(expr.operands[0]);
             return l.builder.CreateNeg(left, DEFAULT("tmp_neg"));
             break;
 
         case Operator::CALL: {
             assert(expr.__state == Expression::COMPOUND);
 
             std::string nameCallee = expr.getValueString();
             shared_ptr<CallStatement> callee(findFunction(nameCallee));
 
             //prepare arguments
             std::vector<llvm::Value *> args;
             args.reserve(expr.operands.size());
 
             std::transform(expr.operands.begin(), expr.operands.end(), std::inserter(args, args.end()),
 				[this](const Expression &operand) {
 					return process(operand);
 				}
             );
 
             ScopePacked outerScopeId = pass->man->clasp->pack(this->scope);
 
             //TASK a) refactor CALL/ADHOC/find function
             //SECTIONTAG late-context propagation arg
             size_t calleeDemandSize = pass->queryContext->getFunctionDemand(nameCallee).size();
             if (calleeDemandSize){
                 DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*>(this->function);
             	llvm::Value* argLateContext = function->contextCompiler.compileContextArgument(nameCallee, outerScopeId);
             	args.push_back(argLateContext);
             }
 
             return (*callee)(move(args), DEFAULT("res_"+nameCallee));
         }
 
         case Operator::IF:
         {
         	return instructions.compileIf(expr, DEFAULT("tmp_if"));
         }
 
         case Operator::SWITCH:
         {
         	return instructions.compileSwitch(expr, DEFAULT("tmp_switch"));
         }
 
         case Operator::LOOP_CONTEXT:
         {
             assert(false);
             return nullptr;
             //return instructions.compileLoopContext(expr, DEFAULT("tmp_loop"));
         }
 
         case Operator::LOGIC_AND: {
         	assert(expr.operands.size() == 1);
         	return process (expr.operands[0]);
         }
 
         case Operator::LIST:
         {
            return instructions.compileListAsSolidArray(expr, DEFAULT("tmp_list"));
         };
 
         case Operator::LIST_RANGE:
         {
             assert(false); //no compilation phase for a range list
           //  return InstructionList(this).compileConstantArray(expr, l, hintRetVar);
         };
 
         case Operator::LIST_NAMED:
         {
             typedef Expanded<TypeAnnotation> ExpandedType;
 
             ExpandedType tyRaw = l.ast->expandType(expr.type);
 
             const std::vector<string> fields = (tyRaw.get().__operator == TypeOperator::CUSTOM)?
                 l.layerExtern->getStructFields(l.layerExtern->lookupType(tyRaw.get().__valueCustom))
                 : tyRaw.get().fields;
 
             std::map<std::string, size_t> indexFields;
             for(size_t i=0, size = fields.size(); i<size; ++i){
                 indexFields.emplace(fields[i], i);
             }
 
             llvm::StructType* tyRecord = llvm::cast<llvm::StructType>(l.toLLVMType(tyRaw));
             llvm::Value* record = llvm::UndefValue::get(tyRecord);
 
             for (size_t i=0; i<expr.operands.size(); ++i){
                 const Expression& operand = expr.operands.at(i);
                 unsigned int fieldId = indexFields.at(expr.bindings.at(i));
 
                 llvm::Value* result = 0;
 
 //TODO Null ad hoc Llvm implementation
 //                if (operand.isNone()){
 //                    llvm::Type* tyNullField = tyRecord->getElementType(fieldId);
 //                    result = llvm::UndefValue::get(tyNullField);
 //
 //                } else {
                     result = process(operand);
 //                }
 
                 assert (result);
                 record = l.builder.CreateInsertValue(record, result, llvm::ArrayRef<unsigned>({fieldId}));
             }
 
             return record;
         };
 
 
 
         case Operator::MAP:
         {
             assert(expr.blocks.size());
             return instructions.compileMapSolidOutput(expr, DEFAULT("map"));
         };
 
         case Operator::FOLD:
         {
             return instructions.compileFold(expr, DEFAULT("fold"));
         };
 
         case Operator::FOLD_INF:
         {
             return instructions.compileFoldInf(expr, DEFAULT("fold"));
         };
 
         case Operator::INDEX:
         {
                 //TODO allow multiindex
             assert(expr.operands.size()==2);
             assert(expr.operands[0].__state == Expression::IDENT);
 
             const std::string& hintIdent= expr.operands[0].getValueString();
             Symbol s = Attachments::get<Symbol>(expr.operands[0]);
             const ExpandedType& t2 = pass->man->root->expandType(CodeScope::getDeclaration(s).type);
 
             llvm::Value* aggr  = processSymbol(s, hintIdent);
 
             switch (t2.get().__operator)
             {
                 case TypeOperator::STRUCT: case TypeOperator::CUSTOM:
                 {
                     const Expression& idx = expr.operands.at(1);
                     assert(idx.__state == Expression::STRING);
                     std::string idxField = idx.getValueString();
 
                     return instructions.compileStructIndex(aggr, t2, idxField);
                 };
 
                 case TypeOperator::ARRAY: {
                     std::vector<llvm::Value*> indexes;
                     std::transform(++expr.operands.begin(), expr.operands.end(), std::inserter(indexes, indexes.end()),
                         [this] (const Expression& op){
                             return process(op);
                         }
                     );
 
                     return instructions.compileArrayIndex(aggr, indexes, DEFAULT(string("el_") + hintIdent));
                 };
 
                 default:
                     assert(false);
             }
         };
 
         	//SECTIONTAG adhoc actual compilation
                 //TODO a) make sure that it's correct: function->adhocImplementation built for Entry scope and used in another scope
         case Operator::ADHOC: {
             DefaultFunctionUnit* function = dynamic_cast<DefaultFunctionUnit*>(this->function);
             assert(function->adhocImplementation && "Adhoc implementation not found");
             const Expression& comm = AdhocExpression(expr).getCommand();
 
             CodeScope* scope = function->adhocImplementation->getCommandImplementation(comm);
             AbstractCodeScopeUnit* unitScope = function->getScopeUnit(scope);
 
             //SECTIONTAG types/convert ADHOC ret convertation
             llvm::Type* resultTy = l.toLLVMType( pass->man->root->expandType(function->adhocImplementation->getResultType()));
             return doAutomaticTypeConversion(unitScope->compile(), resultTy, l.builder);
         };
 
         case Operator::CALL_INTRINSIC:{
             const std::string op = expr.getValueString();
 
             if (op == "copy") {
                 llvm::Value* result = process(expr.getOperands().at(0));
 
                 auto decoratorVersions = Decorators<VersionsScopeDecoratorTag>::getInterface(this);
                 llvm::Value* storage = decoratorVersions->processIntrinsicInit(result->getType());
                 decoratorVersions->processIntrinsicCopy(result, storage);
 
                 return l.builder.CreateLoad(storage, hintVarDecl);
             }
 
             assert(false && "undefined intrinsic");
         }
 
         case Operator::NONE:
             assert(expr.__state != Expression::COMPOUND);
 
             switch (expr.__state) {
                 case Expression::IDENT: {
                     Symbol s = Attachments::get<Symbol>(expr);
                     return processSymbol(s, expr.getValueString());
                 }
 
                 case Expression::NUMBER: {
                     llvm::Type* typConst;
 
                     if (expr.type.isValid()){
                         typConst = l.toLLVMType(pass->man->root->expandType(expr.type));
 
                     } else {
                         typConst = llvm::Type::getInt32Ty(llvm::getGlobalContext());
                     }
 
                     int literal = expr.getValueDouble();
                     return llvm::ConstantInt::get(typConst, literal);
                 }
 
                 case Expression::STRING: {
                     return instructions.compileConstantStringAsPChar(expr.getValueString(), DEFAULT("tmp_str"));
                 };
 
                 case Expression::VARIANT: {
                 	const ExpandedType& typVariant = pass->man->root->expandType(expr.type);
                 	llvm::Type* typRaw = l.toLLVMType(typVariant);
                 	int value = expr.getValueDouble();
                     return llvm::ConstantInt::get(typRaw, value);
                 }
 
                 default: {
                     break;
                 }
             };
 
             break;
 
         default: break;
 
     }
 
     assert(false);
     return 0;
 }
 
 llvm::Value*
 BasicCodeScopeUnit::compile(const std::string& hintBlockDecl){
     if (!hintBlockDecl.empty()) {
         llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
         pass->man->llvm->builder.SetInsertPoint(block);
     }
 
     Symbol symbScope = Symbol{ScopedSymbol::RetSymbol, scope};
     return processSymbol(symbScope);
 }
 
+AbstractCodeScopeUnit::~AbstractCodeScopeUnit()
+{}
+
+FunctionUnit::~FunctionUnit()
+{}
+
 llvm::Function*
 FunctionUnit::compile(){
     if (raw != nullptr) return raw;
 
     LLVMLayer* llvm = pass->man->llvm;
     llvm::IRBuilder<>& builder = llvm->builder;
 
     string&& functionName = prepareName();
     std::vector<llvm::Type*>&& types = prepareArguments();
     llvm::Type* expectedResultType = prepareResult();
 
     llvm::FunctionType *ft = llvm::FunctionType::get(expectedResultType, types, false);
     raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(functionName, ft));
     prepareBindings();
 
 
     const std::string&blockName =  "entry";
     llvm::BasicBlock* blockCurrent = builder.GetInsertBlock();
 
     llvm::Value* result =getScopeUnit(function->__entry)->compile(blockName);
     assert(result);
 
     //SECTIONTAG types/convert function ret value
     builder.CreateRet(doAutomaticTypeConversion(result, expectedResultType, llvm->builder));
 
     if (blockCurrent){
     	builder.SetInsertPoint(blockCurrent);
     }
 
     llvm->moveToGarbage(ft);
     return raw;
 }
 
 AbstractCodeScopeUnit*
 FunctionUnit::getScopeUnit(CodeScope* scope){
-    if (!scopes.count(scope)){
-    	AbstractCodeScopeUnit* unit = new DefaultScopeUnit(scope, this, pass);
-        scopes.emplace(scope, std::unique_ptr<AbstractCodeScopeUnit>(unit));
+    if (__scopes.count(scope)) {
+        auto result = __scopes.at(scope).lock();
+
+        if (result){
+            return result.get();
+        }
     }
 
-    return scopes.at(scope).get();
-}
+    std::shared_ptr<AbstractCodeScopeUnit> unit(new DefaultScopeUnit(scope, this, pass));
 
-AbstractCodeScopeUnit*
-FunctionUnit::getEntry(){
-	return getScopeUnit(function->getEntryScope());
+    if (scope->__parent != nullptr){
+        auto parentUnit = Decorators<CachedScopeDecoratorTag>::getInterface(getScopeUnit(scope->__parent));
+        parentUnit->registerChildScope(unit);
+
+    } else {
+        __orphanedScopes.push_back(unit);
+    }
+
+    if (!__scopes.emplace(scope, unit).second){
+        __scopes[scope] = unit;
+    }
+
+    return unit.get();
 }
 
 AbstractCodeScopeUnit*
 FunctionUnit::getScopeUnit(ManagedScpPtr scope){
     return getScopeUnit(&*scope);
 }
 
+AbstractCodeScopeUnit*
+FunctionUnit::getEntry(){
+	return getScopeUnit(function->getEntryScope());
+}
+
+
+
 FunctionUnit*
 CompilePass::getFunctionUnit(const ManagedFnPtr& function){
 	unsigned int id = function.id();
 
     if (!functions.count(id)){
     	FunctionUnit* unit = new DefaultFunctionUnit(function, this);
         functions.emplace(id, unit);
         return unit;
     }
 
     return functions.at(id);
 }
 
 void
 CompilePass::run(){
     managerTransformations = new TransformationsManager();
     targetInterpretation = new TargetInterpretation(this->man->root, this);
     queryContext = reinterpret_cast<ContextQuery*> (man->clasp->getQuery(QueryId::ContextQuery));
 
     //Find out main function;
     ClaspLayer::ModelFragment model = man->clasp->query(Config::get("function-entry"));
     assert(model && "Error: No entry function found");
     assert(model->first != model->second && "Error: Ambiguous entry function");
 
     string nameMain = std::get<0>(ClaspLayer::parse<std::string>(model->first->second));
     FunctionUnit* unitMain = getFunctionUnit(man->root->findFunction(nameMain));
     entry = unitMain->compile();
 }
 
 llvm::Function*
 CompilePass::getEntryFunction(){
 	assert(entry);
 	return entry;
 }
 
 void
 CompilePass::prepareQueries(ClaspLayer* clasp){
 	clasp->registerQuery(new containers::Query(), QueryId::ContainersQuery);
 	clasp->registerQuery(new ContextQuery(), QueryId::ContextQuery);
-}
\ No newline at end of file
+}
diff --git a/cpp/src/pass/compilepass.h b/cpp/src/pass/compilepass.h
index 2c84988..24b666a 100644
--- a/cpp/src/pass/compilepass.h
+++ b/cpp/src/pass/compilepass.h
@@ -1,167 +1,168 @@
 #ifndef COMPILEPASS_H
 #define COMPILEPASS_H
 
 #include "abstractpass.h"
 
 #include "llvm/IR/Function.h"
 
 namespace xreate {
 	class AdhocScheme;
 	class ClaspLayer;
 	class ContextQuery;
         class LLVMLayer;
 }
 
 //namespace llvm {
 //    class Function;
 //    class Value;
 //    class Type;
 //}
 
 namespace xreate {
 
 class CompilePass;
 
 namespace compilation {
 
 class AbstractCodeScopeUnit;
 class FunctionUnit;
 
 class TargetInterpretation;
 class TransformationsManager;
 
 
 struct Context{
     AbstractCodeScopeUnit* scope;
     FunctionUnit* function;
     CompilePass* pass;
 };
 
 class CallStatement {
 public:
     virtual llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="") = 0;
 };
 
 class CallStatementRaw: public CallStatement{
 public:
     CallStatementRaw(llvm::Function* callee, LLVMLayer* l)
         : __callee(callee), __calleeTy(callee->getFunctionType()), llvm(l) {}
     CallStatementRaw(llvm::Value* callee, llvm::FunctionType* ty, LLVMLayer* l)
         : __callee(callee), __calleeTy(ty), llvm(l) {}
     llvm::Value* operator() (std::vector<llvm::Value *>&& args, const std::string& hintDecl="");
         
 private:
     llvm::Value* __callee;        
     llvm::FunctionType* __calleeTy;
     
     LLVMLayer* llvm;
 };
 
 class AbstractCodeScopeUnit{
 public:
     CompilePass* const pass;
     FunctionUnit* const function;
     CodeScope* const scope;
     
     AbstractCodeScopeUnit(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass);
-    ~AbstractCodeScopeUnit(){}
+    virtual ~AbstractCodeScopeUnit();
 
     virtual llvm::Value* compile(const std::string& hintBlockDecl="")=0;
     virtual llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="")=0;
     virtual llvm::Value* process(const Expression& expr, const std::string& hintVarDecl="")=0;
     
     virtual void bindArg(llvm::Value* value, std::string&& alias)=0;
     virtual void bindArg(llvm::Value* value, const ScopedSymbol& s)=0;
 
 protected:
     virtual CallStatement* findFunction(const std::string& callee)=0;
 };
 
 class BasicCodeScopeUnit: public AbstractCodeScopeUnit{
 public:
     BasicCodeScopeUnit(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass);
-    ~BasicCodeScopeUnit(){}
 
     llvm::Value* processSymbol(const Symbol& s, std::string hintRetVar="");
     llvm::Value* process(const Expression& expr, const std::string& hintVarDecl="");
     llvm::Value* compile(const std::string& hintBlockDecl="");
     
 protected:
     CallStatement* findFunction(const std::string& callee);
 };
 
 
 
 class IFunctionDecorator {
 protected:
     virtual std::string prepareName() = 0;
     virtual std::vector<llvm::Type*>  prepareArguments() = 0;
     virtual llvm::Type* prepareResult() = 0;
     virtual llvm::Function::arg_iterator prepareBindings() = 0;
     virtual ~IFunctionDecorator(){}
 };
 
 class FunctionUnit: public IFunctionDecorator{
 public:
    FunctionUnit(ManagedFnPtr f, CompilePass* p)
     : function(f), pass(p) {}
+   ~FunctionUnit();
 
     llvm::Function* compile();
 
     AbstractCodeScopeUnit* getEntry();
     AbstractCodeScopeUnit* getScopeUnit(CodeScope* scope);
     AbstractCodeScopeUnit* getScopeUnit(ManagedScpPtr scope);
 
     ManagedFnPtr function;
     llvm::Function* raw = nullptr;
     
 protected:
     CompilePass* pass=nullptr;
     
 private:
-    std::map<CodeScope*, std::unique_ptr<AbstractCodeScopeUnit>> scopes;
+    std::map<CodeScope*, std::weak_ptr<AbstractCodeScopeUnit>> __scopes;
+    std::list<std::shared_ptr<AbstractCodeScopeUnit>> __orphanedScopes;
 };
 
 class BasicFunctionDecorator: public FunctionUnit{
 public:
     BasicFunctionDecorator(ManagedFnPtr f, CompilePass* p)
     : FunctionUnit(f, p) {}
 
 protected:
     std::string prepareName();
     virtual std::vector<llvm::Type*>  prepareArguments();
     virtual llvm::Type* prepareResult();
     virtual llvm::Function::arg_iterator prepareBindings();
 };
 
 } // end of namespace `xreate::compilation`
 
 class CompilePass : public AbstractPass<void> {
     friend class LateContextCompiler;
     friend class LateContextCompiler2;
     friend class compilation::BasicCodeScopeUnit;
     friend class compilation::FunctionUnit;
 
 public:
     compilation::TransformationsManager* managerTransformations;
     compilation::TargetInterpretation* targetInterpretation;
     
     CompilePass(PassManager* manager): AbstractPass<void>(manager) {}
     compilation::FunctionUnit* getFunctionUnit(const ManagedFnPtr& function);
     void run() override;
     llvm::Function* getEntryFunction();
     static void prepareQueries(ClaspLayer* clasp);
     
     
 private:
     //TODO free `functions` in destructor
     std::map<unsigned int, compilation::FunctionUnit*> functions;
     llvm::Function* entry = 0;
 
     ContextQuery* queryContext;
     
 };
 
 }
 
 #endif // COMPILEPASS_H
diff --git a/cpp/tests/dfa.cpp b/cpp/tests/dfa.cpp
index f9a4fb8..c8bc714 100644
--- a/cpp/tests/dfa.cpp
+++ b/cpp/tests/dfa.cpp
@@ -1,12 +1,14 @@
 /*
  * DFGtests.cpp
  *
  *  Created on: Jul 23, 2015
  *      Author: pgess
  */
 #include "passmanager.h"
 #include "pass/dfapass.h"
 
 #include "gtest/gtest.h"
 using namespace xreate;
-using namespace std;
\ No newline at end of file
+using namespace std;
+
+//DEBT dfa tests: dfa scheme, dfa scheme + return value annoation (example: script/testpass/containers...)
diff --git a/cpp/tests/interpretation.cpp b/cpp/tests/interpretation.cpp
index 8d0ade4..62419e9 100644
--- a/cpp/tests/interpretation.cpp
+++ b/cpp/tests/interpretation.cpp
@@ -1,369 +1,381 @@
 #include "attachments.h"
 
 using namespace xreate;
 
 #include "passmanager.h"
 #include "compilation/targetinterpretation.h"
 
 #include "gtest/gtest.h"
 #include "boost/scoped_ptr.hpp"
 
 #define private public
 #include "Parser.h"
 #include "pass/interpretationpass.h"
 
 using namespace xreate;
 using namespace xreate::compilation;
 
 TEST(Interpretation, Analysis_StatementIF_1){
     PassManager* man = PassManager::prepareForCode(
 
 R"Code(
     main = function::bool {
         x = "a":: string.
 
         y = if (x=="b"):: bool; interpretation(force) {
             true
 
         } else {
             false
         }.
 
         y
     }
 )Code"          );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
     Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
     InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);
 
     ASSERT_EQ(INTR_ONLY, dataSymbolY.resolution);
 }
 
 TEST(Interpretation, Compilation_StatementIF_1){
     PassManager* man = PassManager::prepareForCode(
 
 R"Code(
     main = function::int; entry {
         x = "a":: string.
 
         y = if (x=="b"):: string; interpretation(force) {
             1
 
         } else {
             0
         }.
 
         y
     }
 )Code"          );
 
     man->runWithoutCompilation();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(0, result);
 }
 
 TEST(Interpretation, Analysis_StatementIF_InterpretCondition_1){
     PassManager* man = PassManager::prepareForCode(
 
 R"Code(
     main = function(x:: int):: int {
         comm= "inc":: string; interpretation(force).
 
         y = if (comm == "inc")::int {x+1} else {x}.
         y
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     CodeScope* scopeEntry = man->root->findFunction("main")->getEntryScope();
     Symbol symbolY{scopeEntry->getSymbol("y"), scopeEntry};
     InterpretationData& dataSymbolY = Attachments::get<InterpretationData>(symbolY);
 
     ASSERT_EQ(CMPL_ONLY, dataSymbolY.resolution);
     ASSERT_EQ(IF_INTERPRET_CONDITION, dataSymbolY.op);
 }
 
 TEST(Interpretation, Compilation_StatementIF_InterpretCondition_1){
     PassManager* man = PassManager::prepareForCode(
 
 R"Code(
     main = function(x:: int):: int; entry {
         comm= "inc":: string; interpretation(force).
 
         y = if (comm == "inc")::int {x+1} else {x}.
         y
     }
 )Code"          );
 
     man->runWithoutCompilation();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)(int) = (int (*)(int))man->run();
     int result = main(1);
 
     ASSERT_EQ(2, result);
 }
 
 TEST(Interpretation, Compilation_StatementFOLD_INTERPRET_INPUT_1){
     PassManager* man = PassManager::prepareForCode(
 
 R"Code(
     main = function(x:: int):: int; entry {
         commands = ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, x->operand):: int{
             switch(comm)::int
 
             case ("inc"){
                 operand + 1
             }
 
             case ("dec"){
                 operand - 1
             }
 
             case ("double"){
                 operand * 2
             }
         }
     }
 )Code"          );
 
     man->runWithoutCompilation();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     const ManagedFnPtr& funcMain = man->root->findFunction("main");
     InterpretationData& dataBody = Attachments::get<InterpretationData>(funcMain);
     ASSERT_EQ(FOLD_INTERPRET_INPUT, dataBody.op);
 
     int (*main)(int) = (int (*)(int))man->run();
     int result = main(10);
 
     ASSERT_EQ(21, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionNo_1){
     PassManager* man = PassManager::prepareForCode(
 R"Code(
     unwrap = function(data::undef, keys::undef):: undef; interpretation(force){
         loop fold(keys->key::string, data->a):: undef {
            a[key]
         }
     }
 
     start = function::num; entry{
         result = unwrap(
             {
                 a = {
                         b =
                         {
                             c = "core"
                         }
                     }
             }, ["a", "b", "c"])::undef.
 
         result == "core"
     }
 )Code" );
 
     man->runWithoutCompilation();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(1, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionDirect_1){
     PassManager* man = PassManager::prepareForCode(
 R"Code(
     unwrap = function(data:: X):: Y {
         if (data[0] == "a")::Y {0} else {unwrap(data[0])}
     }
 
     entry = function:: i8; entry {
         unwrap([[[["a"]]]]):: i8; interpretation(force)
     }
 )Code" );
 
     man->runWithoutCompilation();
 
     InterpretationPass* pass;
     if (man->isPassRegistered(PassId::InterpretationPass)){
         pass = (InterpretationPass*) man->getPassById(PassId::InterpretationPass);
     } else {
         pass = new InterpretationPass(man);
         pass->run();
     }
 
     InterpretationResolution resolutionActual = pass->process(man->root->findFunction("unwrap"));
     ASSERT_EQ(ANY, resolutionActual);
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(0, result);
 }
 
 TEST(Interpretation, StatementCall_RecursionIndirect_1){
         PassManager* man = PassManager::prepareForCode(
 R"Code(
     funcA = function(data:: X):: Y {
         if (data == "a")::Y {0} else {funcB(data)}
     }
 
     funcB = function(data:: X):: Y {
         if (data == "b")::Y {1} else {funcA(data)}
     }
 
     entry = function:: i8; entry {
         funcA(""):: i8; interpretation(force)
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     ASSERT_DEATH(pass->run(), "Indirect recursion detected");
 }
 
 TEST(Interpretation, PartialIntr_1){
     PassManager* man = PassManager::prepareForCode(
 R"Code(
     evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
         switch(code)::int
          case ("inc")    {argument + 1}
          case ("dec")    {argument - 1}
          case ("double") {argument * 2}
     }
 
     main = function::int; entry {
         commands= ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     InterpretationPass* pass = new InterpretationPass(man);
     pass->run();
 
     ManagedFnPtr fnEvaluate = man->root->findFunction("evaluate");
     InterpretationResolution resFnEvaluate= pass->process(fnEvaluate);
     ASSERT_EQ(CMPL_ONLY, resFnEvaluate);
     ASSERT_TRUE(FunctionInterpretationHelper::needPartialInterpretation(fnEvaluate));
 
     const Expression& exprLoop = man->root->findFunction("main")->__entry->getBody();
     Symbol symbCallEv{{0, VERSION_NONE}, exprLoop.blocks.front()};
     InterpretationData dataCallEv = Attachments::get<InterpretationData>(symbCallEv);
     ASSERT_EQ(CMPL_ONLY, dataCallEv.resolution);
     ASSERT_EQ(CALL_INTERPRET_PARTIAL, dataCallEv.op);
 }
 
 TEST(Interpretation, Compilation_PartialIntr_2){
     PassManager* man = PassManager::prepareForCode(
 R"Code(
     evaluate= function(argument:: num, code:: string; interpretation(force)):: num {
         switch(code)::int
         case ("inc")    {argument + 1}
         case ("dec")    {argument - 1}
         case ("double") {argument * 2}
         case default {argument}
     }
 
     main = function::int; entry {
         commands= ["inc", "double", "dec"]:: [string]; interpretation(force).
 
         loop fold(commands->comm::string, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     man->runWithoutCompilation();
     if (!man->isPassRegistered(PassId::InterpretationPass)){
         InterpretationPass* pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(21, result);
 }
 
 TEST(Interpretation, PartialIntr_3){
     PassManager* man = PassManager::prepareForCode(
 R"Code(
     Command= type variant (INC, DEC, DOUBLE).
 
     evaluate= function(argument:: num, code:: Command; interpretation(force)):: num {
         switch(code)::int
         case (INC)    {argument + 1}
         case (DEC)    {argument - 1}
         case (DOUBLE) {argument * 2}
         case default {argument}
     }
 
     main = function::int; entry {
         commands= [INC, DOUBLE, DEC]:: [Command]; interpretation(force).
 
         loop fold(commands->comm::Command, 10->operand):: int{
             evaluate(operand, comm)
         }
     }
 )Code" );
 
     man->runWithoutCompilation();
     if (!man->isPassRegistered(PassId::InterpretationPass)){
         InterpretationPass* pass = new InterpretationPass(man);
         pass->run();
     }
 
     int (*main)() = (int (*)())man->run();
     int result = main();
 
     ASSERT_EQ(21, result);
 }
 
+TEST(InterpretationExamples, Regexp1){
+    FILE* input = fopen("scripts/dsl/regexp.xreate","r");
+    assert(input != nullptr);
+
+    std::unique_ptr<PassManager> man(PassManager::prepareForCode(input));
+
+    int (*main)() = (int (*)())man->run();
+    int result = main();
+
+    ASSERT_EQ(9, result);
+}
+
 //TOTEST call indirect recursion(w/o tags)
-//TASK implement and test Loop Inf (fix acc types in coco grammar)
\ No newline at end of file
+//TASk implement and test Loop Inf (fix acc types in coco grammar)