diff --git a/coco/xreate.ATG b/coco/xreate.ATG
index fbe17ca..6574680 100644
--- a/coco/xreate.ATG
+++ b/coco/xreate.ATG
@@ -1,454 +1,454 @@
 //TODO add ListLiteral
 //TODO ExprTyped:  assign default(none) type
 
 #include "ast.h"
 #include "ExternLayer.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 skipIdent()
 {
   int kind = 0;
   scanner->ResetPeek();
   while ((kind = scanner->Peek()->kind) == _colon)
     if (scanner->Peek()->kind != _ident)
       return 0;
     
   return kind;  
 }
 
 bool checkParametersList()
 {
   return la->kind == _ident && skipIdent() == _lparen;
 }
 
 bool checkInfix()
 {
   return la->kind == _ident && skipIdent() == _ident;
 }
 
 bool checkIndex()
 {
   return la->kind == _ident && skipIdent()  == _lbrack;
 }
 
 bool checkFuncDecl()
 {
   if (la->kind != _ident) return false;
   
   int xkind = skipIdent();
   Token* y = scanner->Peek();
   return  xkind  == _assign && y->kind == _function;
 }
 
 bool checkAssignment()
 {
   scanner->ResetPeek();
   Token* x = scanner->Peek();
   return la->kind == _ident && x->kind  == _assign;
 }
 
 CHARACTERS
   letter = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz".
   any = ANY - '"'.
   digit = "0123456789".
   cr  = '\r'.
   lf  = '\n'.
   tab = '\t'.
 
 TOKENS
   ident = (letter | '_') {letter | digit | '_'}.
   number = digit {digit}.
   string = '"' { any } '"'.
   function = "function".
   lparen = '('. 
   rparen = ')'.
   lbrack = '['.
   rbrack = ']'.
   equal = "==".
   assign = '='.
   implic = '-' '>'.
   colon = ':'.
   tagcolon   = "::".
 
 COMMENTS FROM "/*" TO "*/" NESTED
 COMMENTS FROM "//" TO lf
 
 IGNORE cr + lf + tab
 
 PRODUCTIONS
 
 Xreate = { ( RuleDecl | InterfaceData | Imprt | IF(checkFuncDecl()) FDecl | TDecl ) }.
 
 Ident<std::wstring& name>
 = ident {':' ident}               (. name = t->val; .).
 
 
 FDecl<> =  							(. std::wstring fname; std::wstring varname; TypeAnnotation typIn; TypeAnnotation typOut; .)
 Ident<fname> assign function 		(. Function* f = new Function(fname);  CodeScope* entry = f->getEntryScope(); .)
 ( Type<typOut>  					(. f->setReturnType(typOut); .)
 | '(' [Ident<varname> tagcolon Type<typIn>   (. f->addArg(std::move(varname), move(typIn)); .)
 {',' Ident<varname> tagcolon Type<typIn>  (. f->addArg(std::move(varname), move(typIn));.)
 }] ')' tagcolon Type<typOut>				(. f->setReturnType(typOut); .)
 {';' FnTag<f> }                           
 ) BDecl<entry>    (. entry->__body.bindType(move(typOut)); root.add(f); .)
 .
 
   /**
    *                          TYPES  
    * 
    */
 TypeTerm<TypeAtom& typ> =                       (. std::wstring tid; .)
   ("string" | "int" | "num" | "float" | "bool") (. typ = Atom<Type_t>(t->val); .)
   .
 
 Type<TypeAnnotation& typ> =  (. TypeAnnotation typ2; TypeAtom typ3; std::wstring tid, field; .)
 ( 
   TList<typ>   
 | TStruct<typ>
 | TypeTerm<typ3> (. typ = TypeAnnotation(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; .)
   '{'
     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()); .)
   '}'.
   
  TDecl =  (. std::wstring ttag; TypeAnnotation t; 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)); .)
     | 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)); .)
   ) '.' 
   .
   
 VDecl<CodeScope* f> =  (. std::wstring vname; Expression e; TypeAnnotation typ;.)
 Ident<vname> assign ExprTyped<e, typ>
       (. f->addDeclaration(move(vname), move(typ), move(e)); .)
 .
 
 BDecl<CodeScope* scope> =           (. Expression body; TypeAnnotation typ; pushContextScope(scope); .)
 '{' { (
     IF(checkAssignment()) VDecl<scope> '.'
-    | ExprTyped<body, typ>              (. scope->setBody(body);  popContextScope(); .)
-)}
+    | ExprTyped<body, typ>              (. scope->setBody(body);.)
+)}										(. popContextScope(); .)
 '}'. 
 
 IfDecl<Expression& e, TypeAnnotation typ> =         (. Expression cond; ManagedScpPtr blockTrue = root.add(new xreate::CodeScope(context.scope)); ManagedScpPtr blockFalse = root.add(new xreate::CodeScope(context.scope));  TypeAnnotation typIf; .)
 "if" '(' Expr<cond> ')' tagcolon Type<typIf> BDecl<&*blockTrue> "else" BDecl<&*blockFalse>
 (. e = Expression(Operator::IF, {cond}); e.addBlock(blockTrue); e.addBlock(blockFalse); .)
 .
 
 LoopDecl<Expression& e, TypeAnnotation& typOut> = 
   (. Expression eIn, eAcc, eFilters; std::wstring varEl, varAcc; TypeAnnotation typEl, typAcc;
     ManagedScpPtr block = root.add(new xreate::CodeScope(context.scope)); .)
    "loop"
    ("map" '(' Expr<eIn> implic Ident<varEl> tagcolon Type<typEl> ')' tagcolon Type<typOut> BDecl<&*block>
       (. e = Expression(Operator::MAP, {eIn}); 
          e.addBindings({Atom<Identifier_t>(varEl)});
          block->addArg(Atom<Identifier_t>(varEl), move(typEl)); 
          e.addBlock(block); .)
   |"fold" '(' Expr<eIn> implic Ident<varEl> tagcolon Type<typEl> ['|' Expr<eFilters> ] ',' Expr<eAcc> implic Ident<varAcc> tagcolon Type<typAcc> ')' tagcolon Type<typOut> BDecl<&*block>
     (.  e = Expression(Operator::FOLD, {eIn, eAcc});
         e.addBindings({Atom<Identifier_t>(varEl), Atom<Identifier_t>(varAcc)});
         block->addArg(Atom<Identifier_t>(varEl), move(typEl));
         block->addArg(Atom<Identifier_t>(varAcc), move(typAcc));
         e.addBlock(block); 
     .)
 ).
    
 SwitchDecl<Expression& eSwitch> =                  (. TypeAnnotation typ; eSwitch = Expression(Operator::SWITCH, {}); .)
  // ["switch" [tagcolon Type<typ> {';' MetaSimpExpr<tag>}]]
   CaseDecl<eSwitch> {CaseDecl<eSwitch>}
 .
   
 CaseDecl<Expression& outer> =                    (. Expression inner(Operator::CASE, {}); 
                                                    ManagedScpPtr scopeCond = root.add(new xreate::CodeScope(context.scope));
                                                    ManagedScpPtr scopeBody = root.add(new xreate::CodeScope(&*scopeCond)); .)
   "case" 
   (   "default"
     | CaseParams<&*scopeCond>                      
   )
   
   BDecl<&*scopeBody>                               (. inner.addBlock(scopeCond); inner.addBlock(scopeBody); outer.addArg(move(inner)); .)     
 .
 
 CaseParams<CodeScope* scope> =           (. Expression e; Expression guard(Operator::LOGIC_AND, {}); pushContextScope(scope); .)
    CaseParam<scope, guard>               
   {',' CaseParam<scope, guard>
   }                                      (. scope->setBody(guard); popContextScope(); .).
   
 CaseParam<CodeScope* scope, Expression& guard> =           (. TypeAnnotation argtyp; Expression condition; .)
   (
     IF(checkAssignment()) VDecl<scope>
    | ExprTyped<condition, argtyp>                                (. guard.addArg(move(condition)); .)
   ).
   
                               /*============================ INTERFACES ===============================*/
 Imprt<> =                           
 "import" "raw" '(' string     (. root.__rawImports.push_back(Atom<String_t>(t->val).get()); .)  
 ')' '.' .
 
 InterfaceData<> = "interface" '('
   (   "dfa" ')'  InterfaceDFA
     | "extern-c" ')' InterfaceExternC
     | "cfa" ')' InterfaceCFA
   ).
   
 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> '}' .    	
 
 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))}); .)
 '(' [ CalleeParams<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)); .)
 ).
 
 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 ===============================*/
 
 ExprTyped<Expression&e, TypeAnnotation& typ> =          (. Expression tag; .)
   Expr<e> [tagcolon Type<typ>           (. e.bindType(move(typ)); .)
   {';' MetaSimpExpr<tag>                (. e.tags.emplace(tag.getValueString(), move(tag)); .)
     
   }]
 .
 
 Expr< Expression& e>         (. Operator op; Expression e2; .)
 = SimExpr< e>		 
   [ RelOp< op>
 SimExpr< e2>      (. e = Expression(op, {e, e2});  .)
   ].
 
 SimExpr< Expression& e>      (. Operator op; Expression e2; .)
 = Term< e>
   { AddOp< op>
     Term< e2>         (. e = Expression(op, {e, e2});.)
 	}.
 
 Term< Expression& e>         (. Operator op; Expression e2; .)
 = Factor< e>
   { MulOp< op>
             Factor< e2>        (. e = Expression(op, {e, e2}); .)
   }.
 
 Factor< Expression& e>       (. std::wstring name; TypeAnnotation typ; .)
 =                        
   (IF (checkParametersList()) Ident< name> 
                                     (. e = Expression(Operator::CALL, {Atom<Identifier_t>(name)}); .)
   '(' [CalleeParams<e>] ')'
   |IF (checkIndex()) Ident<name>    
     lbrack  CalleeParams<e> rbrack  (. e.setOp(Operator::INDEX); e.setValue({Atom<Identifier_t>(name)}); .)
   | Ident< name>                    (. e = Expression(Atom<Identifier_t>(name)); .)
   | ListLiteral<e>                  (. /* tuple */.)    
   | StructLiteral<e>                   (. /* struct */.)    
   | LoopDecl<e, typ>
   | IfDecl<e, typ>  
   | SwitchDecl<e>
 
   | number                          (. e = Expression(Atom<Number_t>(t->val)); .)
   | string                          (. e = Expression(Atom<String_t>(t->val)); .)
   | '-' Factor< e>                  (. e = Expression(Operator::NEG, {e}); .)
   | '(' Expr<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(move(val)); keys.push_back(Atom<Identifier_t>(key)); .)
   } '}'                                         (. e.addBindings(keys.begin(), keys.end()); .)
   .
   
 ListLiteral<Expression& e> =  (. Expression eFrom, eTo; .)
 '['                                                             
 [ Expr<eFrom>                                                   (. e.addArg(std::move(eFrom)); .)
 (".."  Expr<eTo>                                                (. e.addArg(std::move(eTo)); e.setOp(Operator::LIST_RANGE); .)
  |{',' Expr<eFrom>                                              (. e.addArg(std::move(eFrom)); .)
 }                                                               (. e.setOp(Operator::LIST); .) 
 ) ] ']'.
 
 CalleeParams<Expression& e> = (. Expression e2; TypeAnnotation typ; .)
   ExprTyped<e2, typ>		(. e.addArg(std::move(e2)); .)
   {',' ExprTyped<e2, typ> 		(. e.addArg(std::move(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
   | '<'                  (. op = Operator::LSS; .)
   | '>'                  (. op = Operator::GTR; .)
   ).
   
 END Xreate.
diff --git a/config/default.json b/config/default.json
index a0de9f7..7d03a30 100644
--- a/config/default.json
+++ b/config/default.json
@@ -1,50 +1,54 @@
 {
     "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"
       },
       
       "nonevalue": "nonevalue",
       "ret": {
         "symbol": "retv",
         "tag": "ret"
       } 
     },
     
     "tests": { 
       "template": "default",
       
       "templates": {
+		"basic": "EntryFunction*",
         "default": "*-",
         "types": "Types*-",
         "containers": "Containers*-",
         "ast": "AST*",
         "non-containers": "*-Containers*",
-        "libxml2": "libxml2*",
         "log":  "Logging*",
-        "cfg": "CFG.testLoopContextExists"
+        "clang": "ClangAPI*"
+        "cfg": "CFG.*",
+        "skip": "SkipDetection*",
+        "raw-xml": "libxml2*",
+        "xml": "Xml.*"
       }
     }
 }
diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index d3e4c7b..269bdff 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -1,150 +1,149 @@
 cmake_minimum_required(VERSION 2.8.11)
 project(xreate)
 find_package(LLVM REQUIRED CONFIG)
 
 set(LLVM_VERSION ${LLVM_VERSION_MAJOR}.${LLVM_VERSION_MINOR})
 
 link_directories(${LLVM_LIBRARY_DIRS})
 
 set(CMAKE_MODULE_PATH ${CMAKE_CURRENT_LIST_DIR})
 message ("MPATH:" ${CMAKE_MODULE_PATH})
 
 message(STATUS "Found LLVM ${LLVM_PACKAGE_VERSION}")
 message(STATUS "Using LLVMConfig.cmake in: ${LLVM_DIR}")
 #find_package(Clang REQUIRED clangTooling libClang)
 
 set(CMAKE_BUILD_TYPE Debug)
 set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -D_GNU_SOURCE -D__STDC_CONSTANT_MACROS -D__STDC_FORMAT_MACROS -D__STDC_LIMIT_MACROS")
 
 set(POTASSCO_PATH "/opt/potassco/gringo" CACHE PATH "Path to gringo sources")
 set (LIBCLASP_PATH ${POTASSCO_PATH}/build/debug)
 link_directories(${LIBCLASP_PATH})
 
 FILE (GLOB TEST_FILES ./tests/*.cpp)
 message("TEST: " ${TEST_FILES})
 set(SOURCE_FILES
     ${TEST_FILES}
 
     ./src/ast.cpp
     ./src/llvmlayer.cpp ./src/clasplayer.cpp
     #./src/main.cpp
 
     ./src/utils.cpp
     ./src/passmanager.cpp
     ./src/pass/abstractpass.cpp ./src/pass/dfgpass.cpp ./src/pass/compilepass.cpp
     ./src/pass/cfgpass.cpp
     ./src/pass/logging.cpp
     #./src/pass/rulespass.cpp
 
     ./src/instructions/instr-containers.cpp
     ./src/query/containers.cpp
     ./src/query/ptrvalid.cpp
     ./src/attachments.cpp
 
     #${POTASSCO_PATH}/app/shared/src/clingocontrol.cc
     #${POTASSCO_PATH}/app/pyclingo/src/clingo_lib.cc
 )
 
 set(COCO_PATH ${CMAKE_HOME_DIRECTORY}/../coco/)
 set(COCO_SOURCE_FILES  
   ${COCO_PATH}/Parser.h
   ${COCO_PATH}/Scanner.h
   ${COCO_PATH}/Parser.cpp
   ${COCO_PATH}/Scanner.cpp
 )
 
 
 
 INCLUDE_DIRECTORIES(${LLVM_INCLUDE_DIRS})
 INCLUDE_DIRECTORIES("/usr/include/libxml2")
 INCLUDE_DIRECTORIES(${COCO_PATH} ./src)
 INCLUDE_DIRECTORIES(${POTASSCO_PATH}/libgringo
 ${POTASSCO_PATH}/libclasp
 ${POTASSCO_PATH}/libclingo
 ${POTASSCO_PATH}/libprogram_opts
 )
 
 include_directories(${CMAKE_HOME_DIRECTORY}/../vendors/jeayeson/include/)
 
 #execute_process(COMMAND ${COCO_PATH}/gen-xreate WORKING_DIRECTORY  OUTPUT_VARIABLE COCO_OUTPUT)
 
 
 message(STATUS "COCO GRAMMAR BUILD STATUS:" ${COCO_OUTPUT})
     
 include_directories(${LLVM_INCLUDE_DIRS})
 add_definitions(${LLVM_DEFINITIONS})
     
-add_executable(xreate ${SOURCE_FILES} ${COCO_SOURCE_FILES} tests/testLibXml2.cpp src/ExternLayer.cpp src/ExternLayer.h)
+add_executable(xreate ${SOURCE_FILES} ${COCO_SOURCE_FILES} src/ExternLayer.cpp src/ExternLayer.h)
 
 set(COCO_TARGET grammar)
 
 add_custom_target(${COCO_TARGET}
     WORKING_DIRECTORY ${COCO_PATH}
 )
 
 add_custom_command(TARGET ${COCO_TARGET}
     PRE_BUILD
     COMMAND ${COCO_PATH}/gen-grammar
     WORKING_DIRECTORY ${COCO_PATH}
 )
 
 add_custom_target (coverage
     COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/src/code-coverage.sh
     WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
 
 message(STATUS "BINARY DIR" ${CMAKE_BINARY_DIR})
 
 #add_dependencies(${PROJECT_NAME} coverageTarget)
 
 llvm_map_components_to_libnames(llvm_libs support core irreader all native nativecodegen)
 message(STATUS "LLVM LIBS: " ${llvm_libs})
 
 set(LIBCLASP_LIBS
     clingo
     clasp
     gringo
     program_opts
     reify
 )
 
 message(STATUS "CLANG LIBS: " ${CLANG_LIBS})
 message(STATUS "CLASP LIBS: " ${LIBCLASP_LIBS})
 
 
 
-add_definitions(-DWITH_THREADS=0)
+add_definitions(-DWITH_THREADS=1)
 
 FUNCTION(PREPEND var prefix)
    SET(listVar "")
    FOREACH(f ${ARGN})
       LIST(APPEND listVar "${prefix}/${f}")
    ENDFOREACH(f)
    SET(${var} "${listVar}" PARENT_SCOPE)
 ENDFUNCTION(PREPEND)
 
 
 find_package(GTest REQUIRED)
 INCLUDE_DIRECTORIES(${GTEST_INCLUDE_DIRS})
 
-# -fprofile-arcs -ftest-coverage -O0
-set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall")
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -fprofile-arcs -ftest-coverage -O0")
 
 set(CLANG_LIBS
   clangCodeGen
   clangASTMatchers
   clangQuery
   clangTooling
   clangFrontend
   clangSerialization
   clangDriver
   clangParse
   clangSema
   clangAnalysis
   clangAST
   clangEdit
   clangLex
   clangBasic
   )
 
 
 target_link_libraries(xreate ${GTEST_LIBRARIES} LLVM-${LLVM_VERSION} ${LIBCLASP_LIBS} ${CLANG_LIBS}  pthread xml2 gcov tbb)
diff --git a/cpp/src/ExternLayer.cpp b/cpp/src/ExternLayer.cpp
index 6d8c5c1..3a866ab 100644
--- a/cpp/src/ExternLayer.cpp
+++ b/cpp/src/ExternLayer.cpp
@@ -1,276 +1,282 @@
 //
 // Created by pgess on 4/21/15.
 //
 
 #include "ExternLayer.h"
 
 #include <cstdio>
 #include <iostream>
 #include "clang/Tooling/Tooling.h"
 #include "clang/Frontend/ASTUnit.h"
 #include "clang/Frontend/CodeGenOptions.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/Basic/TargetInfo.h"
 #include <llvm/Support/DynamicLibrary.h>
 #include <boost/format.hpp>
 #include <boost/algorithm/string/join.hpp>
 
 using namespace xreate;
 using namespace std;
 using namespace clang;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace clang::ast_matchers;
 using namespace llvm;
 
 
 class FinderCallbackTypeDecl : public MatchFinder::MatchCallback {
 public :
     QualType typeResult;
 
     virtual void run(const MatchFinder::MatchResult &Result) {
         if (const TypedefDecl* decl = Result.Nodes.getNodeAs<clang::TypedefDecl>("typename")) {
             typeResult = decl->getUnderlyingType();
         }
     }
 };
 
 class FinderCallbackFunction : public MatchFinder::MatchCallback {
 public :
     QualType typeResult;
 
     virtual void run(const MatchFinder::MatchResult &Result) {
         if (const FunctionDecl* decl = Result.Nodes.getNodeAs<clang::FunctionDecl>("function")) {
             typeResult = decl->getType();
         }
     }
 };
 
 void
 ExternData::addLibrary(Atom<Identifier_t>&& name, Atom<String_t>&& package)
 {
     __dictLibraries.emplace(name.get(), package.get());
 }
 
 void
 ExternData::addIncludeDecl(Expression&& e)
 {
     assert(e.op == Operator::LIST_NAMED);
 
-        //TODO implement Expression parsing(Array of Expr as vector<string>);
-    int indexLib, indexHeaders;
+        //TODO  ?? implement Expression parsing(Array of Expr as vector<string>);
     for(size_t i=0, size=e.operands.size(); i<size; ++i)
     {
         std::string library = e.bindings.at(i);
         assert(__dictLibraries.count(library));
         std::string package = __dictLibraries.at(library);
 
         Expression listHeaders = e.operands.at(i);
         assert(listHeaders.op == Operator::LIST);
 
         std::vector<std::string> headers;
         std::transform(listHeaders.operands.begin(), listHeaders.operands.end(), std::inserter(headers, headers.end()),
                        [](const Expression& o){
                            assert(o.__state == Expression::STRING);
                            return o.getValueString();
         });
 
         entries.emplace_back(ExternEntry{package, std::move(headers)});
     }
 }
 
 void
 ExternLayer::addExternalData(const std::vector<ExternEntry>& data){
     entries.insert(entries.end(), data.begin(), data.end());
 }
 
-ExternLayer::ExternLayer(LLVMLayer *llvm): __llvm(llvm), __datalayout(llvm->module)
+ExternLayer::ExternLayer(LLVMLayer *llvm)
+    : __datalayout(llvm->module), __llvm(llvm)
 {}
 
 
 std::vector<string>
 ExternLayer::fetchPackageFlags(const ExternEntry& entry){
     std::vector<string> args;
     FILE* flags = popen((string("pkg-config --cflags ") + entry.package).c_str(), "r");
     size_t linesize=0;
     char* linebuf=0;
     ssize_t linelen=0;
     while ((linelen=getdelim(&linebuf, &linesize, ' ', flags))>0) {
         if (linebuf[0]=='\n') continue;
+        if (linelen==1 && linebuf[0]==' ') continue;
         if (linebuf[linelen-1 ] == ' ')
                 linebuf[linelen-1] = 0;
 
         llvm::outs() << '<' << linebuf << "> ";
         args.push_back(linebuf);
 
         free(linebuf);
         linebuf = 0;
     }
     pclose(flags);
     return (args);
 }
 
 std::vector<string>
 ExternLayer::fetchPackageLibs(const ExternEntry& entry){
 	std::vector<string> libs;
 
 	FILE* flags = popen((string("pkg-config --libs ") + entry.package).c_str(), "r");
 	size_t linesize=0;
 	char* linebuf=0;
 	ssize_t linelen=0;
 	while ((linelen=getdelim(&linebuf, &linesize, ' ', flags))>0) {
 		if (linebuf[0]=='\n') continue;
-		if (linebuf[linelen-1 ] == ' ')
-				linebuf[linelen-1] = 0;
+        if (linelen==1 && linebuf[0]==' ') continue;
+        if (linebuf[linelen-1 ] == ' ')
+                linebuf[linelen-1] = 0;
+        if (linelen>=2 && linebuf[0] == '-' && linebuf[1] == 'l'){
+            libs.push_back(linebuf + 2);
+        } else {
+            libs.push_back(linebuf);
+        }
 
 		llvm::outs() << '<' << linebuf << "> ";
-		libs.push_back(linebuf);
-
 		free(linebuf);
 		linebuf = 0;
 	}
 	pclose(flags);
 	return (libs);
 }
 
 void
 ExternLayer::loadLibraries(vector<string>&& libs){
 	string msgErr;
     for (const string& lib: libs) {
-    	if (!llvm::sys::DynamicLibrary::LoadLibraryPermanently(lib.c_str(), &msgErr)){
-    		llvm::errs()<<"\n"<<msgErr<<"\n";
+        const string& libName = string("lib")+lib+".so";
+        if (!llvm::sys::DynamicLibrary::LoadLibraryPermanently(libName.c_str(), &msgErr)){
+            llvm::errs()<<"\n"<<"Loading library "<<lib<<". " <<msgErr<<"\n";
     	}
     }
 }
 
 void
 ExternLayer::init(const AST* root) {
     addExternalData(root->__externdata);
 
+    	// TODO use default include path from 'clang -xc++ -E'
     list<string> code;
     std::vector<string> args{
         "-I/usr/include"
         ,"-I/usr/local/include"
-        ,"-I/usr/lib/llvm-3.6/lib/clang/3.6.0/include"
+        ,"-I/usr/lib/llvm-3.6/lib/clang/3.6.2/include"
 //        ,"-I/usr/lib/gcc/x86_64-linux-gnu/4.9/include"
 //        ,"-I/usr/include/x86_64-linux-gnu"
     };
 
     std::vector<string> libs;
 
     boost::format formatInclude("#include \"%1%\"");
     for(const ExternEntry& entry: entries)
     {
         llvm::outs()<<"[ExternC] Processing package: "<< entry.package << "\n";
         llvm::outs()<<"[ExternC]    args: ";
 
         vector<string>&& args2 = fetchPackageFlags(entry);
         args.insert(args.end(), args2.begin(), args2.end());
         for(const string arg: args2) {
         	llvm::outs()<< "<" << arg << "> ";
         }
 
         llvm::outs()<<"\n[ExternC]    libs: ";
         args2 = fetchPackageLibs(entry);
         for(const string arg: args2) {
         	llvm::outs()<< "<" << arg << "> ";
         }
         libs.insert(libs.end(), args2.begin(), args2.end());
 
 
         llvm::outs()<<"\n[ExternC]    headers: ";
         std::transform(entry.headers.begin(), entry.headers.end(), std::inserter(code, code.begin()),
             [&formatInclude](const string header ) {
                 string line = boost::str(formatInclude % header);
                 llvm::outs()<< "<" << line << "> ";
 
                 return line;
         });
 
         llvm::outs() << '\n';
     }
 
-            //TODO uncomment loadLibraries
-    //loadLibraries(move(libs));
+    loadLibraries(move(libs));
     ast = buildASTFromCodeWithArgs(boost::algorithm::join(code, "\n"), args);
     __cgo.reset(new CodeGenOptions);
     __datalayout = llvm::DataLayout(ast->getASTContext().getTargetInfo().getTargetDescription());
     __cgm.reset(new CodeGen::CodeGenModule(ast->getASTContext(), *__cgo, *__llvm->module, __datalayout, ast->getASTContext().getDiagnostics()));
 };
 
 
 
 bool
 ExternLayer::isPointer(const clang::QualType &t) {
     const clang::Type * tInfo = t.getTypePtr();
     assert(tInfo);
 
     return tInfo->isAnyPointerType();
 }
 
 llvm::Type*
 ExternLayer::toLLVMType(const clang::QualType& t){
     return __cgm->getTypes().ConvertType(t);
 }
 
 std::vector<std::string>
 ExternLayer::getStructFields(const clang::QualType& ty)
 {
     clang::QualType t = ty;
     if (isPointer(ty)){
         const clang::PointerType* tPtr = ty->getAs<clang::PointerType>();
         t = tPtr->getPointeeType();
     }
 
     assert(t.getTypePtr()->isRecordType());
 
     const RecordType *record = t->getAsStructureType();
     assert(record);
 
     std::vector<std::string> result;
     //FieldDecl* field: record->getDecl()->fields()
     for (auto i=record->getDecl()->field_begin(); i!= record->getDecl()->field_end(); ++i){
         result.push_back(i->getName());
     }
 
     return result;
 }
 
 clang::QualType
 ExternLayer::lookupType(const std::string& id){
     MatchFinder finder;
     FinderCallbackTypeDecl callbackTypeDecl;
     auto matcherTypeDecl = typedefDecl(hasName(id)).bind("typename");
 
     finder.addMatcher(matcherTypeDecl, &callbackTypeDecl);
     finder.matchAST(ast->getASTContext());
 
     assert(! callbackTypeDecl.typeResult.isNull());
     return callbackTypeDecl.typeResult;
 }
 
 
 llvm::Function*
 ExternLayer::lookupFunction(const std::string& name){
 	if (__functions.count(name)){
 		return __functions.at(name);
 	}
 
     MatchFinder finder;
     FinderCallbackFunction callback;
     auto matcher = functionDecl(hasName(name)).bind("function");
 
     finder.addMatcher(matcher, &callback);
     finder.matchAST(ast->getASTContext());
 
     assert(! callback.typeResult.isNull());
     const QualType& tyFuncQual = callback.typeResult;
     llvm::Type *tyRaw =  __cgm->getTypes().ConvertType(tyFuncQual);
     llvm::FunctionType* tyRawFunc = llvm::dyn_cast<llvm::FunctionType>(tyRaw);
 
     llvm::Function* function = llvm::Function::Create(tyRawFunc, llvm::GlobalValue::ExternalLinkage, name, __llvm->module);
 
     __functions.emplace(name, function);
     return function;
 }
diff --git a/cpp/src/ast.cpp b/cpp/src/ast.cpp
index 6db5f2f..ea80e4b 100644
--- a/cpp/src/ast.cpp
+++ b/cpp/src/ast.cpp
@@ -1,642 +1,642 @@
 #include "ast.h"
 #include "ExternLayer.h"
 #include <stdexcept>
 #include <iostream>
 #include <clasplayer.h>
 
 using namespace std;
 
 namespace xreate{
 
 class TypesResolver {
 private:
 	const AST* ast;
 	std::map<std::string, TypeAnnotation> scope;
 	std::map<TypeAnnotation, int> signatures;
 
 
 	ExpandedType expandType(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()){
 		return TypesResolver(ast, scope, signatures)(t, args);
 	}
 
 	std::vector<TypeAnnotation>
 	expandOperands(const std::vector<TypeAnnotation>&  operands) {
 		std::vector<TypeAnnotation> pack;
 
 		pack.reserve(operands.size());
 	    std::transform(operands.begin(), operands.end(), std::inserter(pack, pack.end()),
 	                   [this](const TypeAnnotation& t){
 	                       return expandType(t);
 	                   });
 
 	    return pack;
 	}
 
 public:
 	TypesResolver(const AST* root, const std::map<std::string, TypeAnnotation>& scopeOuter = std::map<std::string, TypeAnnotation>(),
 			std::map<TypeAnnotation, int> signaturesOuter = std::map<TypeAnnotation, int>())
 	: ast(root), scope(scopeOuter), signatures(signaturesOuter) {
 	}
 
 
 
 	ExpandedType
 	operator()(const TypeAnnotation &t, const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>())
 	{
 	    assert(args.size() == t.bindings.size()); // invalid number of arguments
-	    for (int i=0; i<args.size(); ++i)
+        for (size_t i=0; i<args.size(); ++i)
 	    {
 	        scope[t.bindings.at(i)] =  args.at(i);
 	    }
 
 	    switch (t.__operator)
 	    {
 	        case TypeOperator::ARRAY:
 	        {
 	            assert(t.__operands.size()==1);
 
 	            Expanded<TypeAnnotation> elTy = expandType(t.__operands.at(0));
 	            return ExpandedType(TypeAnnotation(tag_array, elTy, t.__size));
 	        }
 
 	        case TypeOperator::STRUCT:
 	        {
 	            assert(t.__operands.size());
 
 	            std::vector<TypeAnnotation>&& pack = expandOperands(t.__operands);
 	            auto tnew = TypeAnnotation(TypeOperator::STRUCT, move(pack));
 	            tnew.fields = t.fields;
 
 	            return ExpandedType(move(tnew));
 	        };
 
 	        case TypeOperator::CALL:
 	        {
 	            std::string alias = t.__valueCustom;
 
 	            		//find in local scope:
 	            TypeAnnotation ty;
 	            if (scope.count(alias))            {
 	                ty = scope.at(alias);
 
 	            } else if (ast->__indexTypeAliases.count(alias)){
 	            	ty = ast->__indexTypeAliases.at(alias);
 
 	            } else {
 	            	assert(false && "Undefined or external type");
 	            }
 
 	            std::vector<TypeAnnotation>&& operands = expandOperands(t.__operands);
 	            TypeAnnotation signature(TypeOperator::CALL, move(operands));
 	            signature.__valueCustom = alias;
 
 				if (signatures.count(signature)) {
 						auto link = TypeAnnotation(TypeOperator::LINK, {});
 						link.conjuctionId = signatures.at(signature);
 
 						return ExpandedType(move(link));
 				}
 
 				int cid = signatures.size();
 				signatures[signature] = cid;
 	            TypeAnnotation tyResult = expandType(ty, operands);
 	            tyResult.conjuctionId = cid;
 
 	            return ExpandedType(move(tyResult));
 	        };
 
 	        case TypeOperator::CUSTOM:
 	        {
 	            std::string alias = t.__valueCustom;
 
 	            /*
 	            if (signatures.count(alias)) {
 	            	return ExpandedType(TypeAnnotation(TypeOperator::LINK, {t}));
 	            }
 	            signatures[alias].emplace(t);
 	            */
 
 	            //find in local scope:
 	            if (scope.count(alias))
 	            {
 	                return expandType(scope.at(alias));
 	            }
 
 	            // find in general scope:
 	            if(ast->__indexTypeAliases.count(alias)) {
 	                return expandType(ast->__indexTypeAliases.at(t.__valueCustom));
 	            }
 
 	            //if type is unknown keep it as is.
 	            return ExpandedType(TypeAnnotation(t));
 	        };
 
 	        case TypeOperator::ACCESS:
 	        {
 	        	std::string alias = t.__valueCustom;
 	        	ExpandedType tyAlias= ExpandedType(TypeAnnotation());
 
 	        			//find in local scope:
 				if (scope.count(alias)) {
 					tyAlias = expandType(scope.at(alias));
 
 						//find in global scope:
 				} else if((ast->__indexTypeAliases.count(alias))) {
 					tyAlias = expandType(ast->__indexTypeAliases.at(alias));
 
 				} else {
 					assert(false && "Undefined or external type");
 				}
 
 				assert(tyAlias->__operator == TypeOperator::STRUCT);
 
 				for (const string& field: t.fields){
 					auto fieldIt = std::find(tyAlias->fields.begin(), tyAlias->fields.end(), field);
 					assert(fieldIt != tyAlias->fields.end() && "unknown field");
 
 					int fieldId =  fieldIt -  tyAlias->fields.begin();
 					tyAlias = expandType(tyAlias->__operands.at(fieldId));
 				}
 
 				return tyAlias;
 	        }
 
 	        case TypeOperator::TUPLE: {
 	            assert(t.__operands.size());
 
 	            std::vector<TypeAnnotation> pack;
 	            pack.reserve(t.__operands.size());
 
 	            std::transform(t.__operands.begin(), t.__operands.end(), std::inserter(pack, pack.end()),
 	                           [this](const TypeAnnotation& t){
 	                               return expandType(t);
 	                           });
 
 	            return ExpandedType(TypeAnnotation(TypeOperator::TUPLE, move(pack)));
 	        }
 
 	        case TypeOperator::NONE: {
 	            return ExpandedType(TypeAnnotation(t));
 	        }
 
 	        default:
 	            assert(false);
 	    }
 
 	    assert(false);
 	    return  ExpandedType(TypeAnnotation());
 	}
 };
 
 TypeAnnotation::TypeAnnotation()
 {
 }
 
 TypeAnnotation::TypeAnnotation(const Atom<Type_t> &typ)
     : __value(typ.get())
 {
     ;
 }
 
 TypeAnnotation::TypeAnnotation (TypePrimitive typ)
     : __value(typ)
 {}
 
 TypeAnnotation::TypeAnnotation(TypeOperator op, std::initializer_list<TypeAnnotation> operands)
     : __operator(op), __operands(operands)
 {
 
 }
 
 TypeAnnotation::TypeAnnotation (TypeOperator op, std::vector<TypeAnnotation>&& operands)
         : __operator(op), __operands(operands)
 {}
 
 
 TypeAnnotation::TypeAnnotation (llvm_array_tag, TypeAnnotation typ, int size)
     :TypeAnnotation(TypeOperator::ARRAY, {typ})
 {
     __size=size;
 }
 
 bool
 TypeAnnotation::operator< (const TypeAnnotation& t) const{
 	if (__operator != t.__operator) return __operator < t.__operator;
 
 	if (__operator == TypeOperator::NONE)
 		return __value < t.__value;
 
 	if (__operator == TypeOperator::CALL || __operator == TypeOperator::CUSTOM || __operator == TypeOperator::ACCESS){
 			if (__valueCustom != t.__valueCustom)
 				return __valueCustom < t.__valueCustom;
 	}
 
 	return __operands < t.__operands;
 }
 
 /*
 TypeAnnotation (struct_tag, std::initializer_list<TypeAnnotation>)
 {}
 */
 
 void
 TypeAnnotation::addBindings(std::vector<Atom<Identifier_t>>&& params)
 {
     bindings.reserve(params.size());
 
     std::transform(params.begin(), params.end(), std::inserter(bindings, bindings.end()),
         [](const Atom<Identifier_t>& ident){return ident.get(); });
 }
 
 Expression::Expression(const Atom<Number_t>& number)
 : __state(NUMBER), op(Operator::NONE), __valueD(number.get())
 {
 }
 
 Expression::Expression(const Atom<String_t>& a)
         : __state(STRING), op(Operator::NONE), __valueS(a.get())
 {
 }
 
 Expression::Expression(const Atom<Identifier_t> &ident)
     : __state(IDENT), op(Operator::NONE), __valueS(ident.get())
 {
 
     if (ident.get() == "null") {
         __state = NONE;
     }
 }
 
 Expression::Expression(const Operator &oprt, std::initializer_list<Expression> params)
     : __state(COMPOUND), op(oprt)
 {
     if (op == Operator::CALL)
     {
         assert(params.size() > 0);
         Expression arg = *params.begin();
 
         assert(arg.__state == Expression::IDENT);
         __valueS = std::move(arg.__valueS);
 
         operands.insert(operands.end(), params.begin()+1, params.end());
         return;
     }
 
     operands.insert(operands.end(), params.begin(), params.end());
 }
 
 void
 Expression::setOp(Operator oprt)
 {
     op = oprt;
 
     switch (op)
     {
         case Operator::NONE:
             __state = INVALID;
             break;
 
         default:
             __state = COMPOUND;
             break;
     }
 }
 
 void
 Expression::addArg(Expression &&arg)
 {
     operands.push_back(arg);
 }
 
 void
 Expression::addBindings(std::initializer_list<Atom<Identifier_t>> params)
 {
     addBindings(params.begin(), params.end());
 }
 
 void
 Expression::bindType(TypeAnnotation&& t)
 {
     type = t;
 }
 
 void
 Expression::addBlock(ManagedScpPtr scope)
 {
     blocks.push_back(scope.operator ->());
 }
 
 const std::vector<Expression>&
 Expression::getOperands() const
 {
     return operands;
 }
 
 double
 Expression::getValueDouble() const
 {
     return __valueD;
 }
 
 const std::string&
 Expression::getValueString() const
 {
     return __valueS;
 }
 
 void
 Expression::setValue(const Atom<Identifier_t>&& v){
     __valueS = v.get();
 }
 
 bool
 Expression::isNone() const{
     return (op == Operator::NONE && __state == NONE);
 }
 
 bool
 Expression::isValid() const{
     return (__state != INVALID);
 }
 
 Expression::Expression()
-    : op(Operator::NONE), __state(INVALID)
+    : __state(INVALID), op(Operator::NONE)
 {}
 
 
 AST::AST()
 {
 }
 
 
 void
 AST::addInterfaceData(const ASTInterface& interface, Expression&& data ) {
 	__interfacesData.emplace(interface, move(data));
 }
 
 void
 AST::addDFAData(Expression &&data) {
     __dfadata.push_back(data);
 }
 
 void
 AST::addExternData(ExternData &&data) {
     __externdata.insert(__externdata.end(), data.entries.begin(), data.entries.end());
 }
 
 void
 AST::add(Function* f)
 {
     __functions.push_back(f);
     __indexFunctions[f->getName()] = __functions.size()-1;
 }
 
 void
 AST::add(MetaRuleAbstract *r)
 {
     __rules.push_back(r);
 }
 
 void
 AST::add(TypeAnnotation&& t, Atom<Identifier_t>&& alias){
     __indexTypeAliases.emplace(alias.get(), t);
 }
 
 ManagedScpPtr
 AST::add(CodeScope* scope)
 {
     this->__scopes.push_back(scope);
     return ManagedScpPtr(this->__scopes.size()-1, &this->__scopes);
 }
 
 std::string
 AST::getModuleName()
 {
     const std::string name = "moduleTest";
 
     return name;
 }
 
 ManagedPtr<Function>
 AST::findFunction(const std::string& name)
 {
     if (! __indexFunctions.count(name)) {
     	return ManagedFnPtr::Invalid();
     }
     return ManagedPtr<Function>(__indexFunctions.at(name), &__functions);
 }
 
     template<>
 ManagedPtr<Function>
 AST::begin<Function>()
 {return ManagedPtr<Function>(0, &this->__functions);}
 
 template<>
 ManagedPtr<CodeScope>
 AST::begin<CodeScope>()
 {return ManagedPtr<CodeScope>(0, &this->__scopes);}
 
 template<>
 ManagedPtr<MetaRuleAbstract>
 AST::begin<MetaRuleAbstract>()
 {return ManagedPtr<MetaRuleAbstract>(0, &this->__rules);}
 
 
 Expanded<TypeAnnotation>
 AST::expandType(const TypeAnnotation &t) const
 {
     return TypesResolver(this)(t);
 }
 
 Expanded<TypeAnnotation>
 AST::findType(const std::string& name){
 			// find in general scope:
     if(__indexTypeAliases.count(name))
         return expandType(__indexTypeAliases.at(name));
 
     		//if type is unknown keep it as is.
     TypeAnnotation t(TypeOperator::CUSTOM, {});
     t.__valueCustom = name;
     return ExpandedType(move(t));
 }
 
 Function::Function(const Atom<Identifier_t>& name)
     : __entry(new CodeScope(0))
 {
     __name = name.get();
 }
 
 void
 Function::addTag(Expression&& tag, const TagModifier mod)
 {
     __tags.emplace_back(tag, mod);
 }
 
 const std::vector<Tag>&
 Function::getAnnotations() const
 {
     return __tags;
 }
 
 CodeScope*
 Function::getEntryScope() const
 {
     return __entry;
 }
 
 void
 CodeScope::addArg(Atom <Identifier_t>&& name, TypeAnnotation&& typ)
 {
-    VID id = registerVar(std::move(const_cast<std::string&>(name.get())), std::move(typ));
+    registerVar(std::move(const_cast<std::string&>(name.get())), std::move(typ));
     __args.push_back(name.get());
 }
 
      ;
 
 void
 Function::addArg(Atom <Identifier_t>&& name, TypeAnnotation&& typ)
 {
     __entry->addArg(move(name), move(typ));
 }
 
 void
 Function::setReturnType(const TypeAnnotation &rtyp)
 {
     __entry->__definitions[0] = rtyp;
 }
 
 const std::string&
 Function::getName() const
 {
     return __name;
 }
 
 CodeScope::CodeScope(CodeScope* parent)
     :__parent(parent)
 {}
 
 CodeScope::~CodeScope()
 {}
 
 VID
 CodeScope::registerVar(std::string&& name, TypeAnnotation &&typ)
 {
     __vartable[name] = ++__vCounter;
     __definitions[__vCounter] = typ;
 
     return  __vCounter;
 }
 
 void
 CodeScope::addDeclaration(const Atom <Identifier_t> &&name, TypeAnnotation &&typ, Expression&& body)
 {
     VID id  = registerVar(std::move(const_cast<string&>(name.get())), move(typ));
     __declarations[id] = body;
 }
 
 void
 CodeScope::setBody(const Expression &body)
 {
     __body = body;
 }
 
 TypeAnnotation&
 CodeScope::findDefinition(const Symbol& symbol)
 {
     CodeScope* self = symbol.scope;
     assert(self->__definitions.count(symbol.identifier));
     return self->__definitions[symbol.identifier];
 }
 
 Symbol
 CodeScope::findSymbol(const std::string &name)
 {
         //search var in current block
     if (__vartable.count(name))
     {
         VID vId = __vartable.at(name);
         Symbol result{vId, this};
         return result;
     }
 
         //search in parent scope
     if (__parent)
     {
         return __parent->findSymbol(name);
     }
 
     //exception: Ident not found
-    assert(false);
+    assert(false && "Symbol not found");
 }
 
 
 
 bool
 CodeScope:: hasDeclaration(const Symbol& symbol)
 {
     CodeScope* self = symbol.scope;
     return (self->__declarations.count(symbol.identifier));
 }
 
 const Expression&
 CodeScope::findDeclaration(const Symbol& symbol)
 {
     CodeScope* self = symbol.scope;
 
     if (! self->__declarations.count(symbol.identifier))
     {
             // no declaration exists
         assert(false);
     }
 
     return self->__declarations[symbol.identifier];
 }
 
 
 
 void
 RuleArguments::add(const Atom<Identifier_t> &arg, DomainAnnotation typ)
 {
     emplace_back(arg.get(), typ);
 }
 
 void
 RuleGuards::add(Expression&& e)
 {
     push_back(e);
 }
 
 MetaRuleAbstract::
 MetaRuleAbstract(RuleArguments&& args, RuleGuards&& guards)
     : __args(std::move(args)), __guards(std::move(guards))
 {}
 
 MetaRuleAbstract::~MetaRuleAbstract(){}
 
 RuleWarning::
 RuleWarning(RuleArguments&& args, RuleGuards&& guards, Expression&& condition, Atom<String_t>&& message)
-    : MetaRuleAbstract(std::move(args), std::move(guards)), __condition(condition), __message(message.get())
+    : MetaRuleAbstract(std::move(args), std::move(guards)), __message(message.get()), __condition(condition)
 {}
 
 RuleWarning::~RuleWarning(){}
 
 void
 RuleWarning::compile(ClaspLayer& layer)
 {
     layer.addRuleWarning(*this);
 }
 
 bool operator< (const Symbol& s1, const Symbol& s2)
 {
     return (s1.scope < s2.scope) || (s1.scope==s2.scope && s1.identifier<s2.identifier);
 }
 
 bool operator== (const Symbol& s1, const Symbol& s2)
 {
     return (s1.scope == s2.scope) && (s1.identifier==s2.identifier);
 }
 }
 
 
 
 
diff --git a/cpp/src/ast.h b/cpp/src/ast.h
index 973ea60..c1ddc4b 100644
--- a/cpp/src/ast.h
+++ b/cpp/src/ast.h
@@ -1,518 +1,519 @@
 #ifndef AST_H
 #define AST_H
 
 #include <vector>
 #include <stdlib.h>
 #include <string>
 #include <list>
 #include <unordered_map>
 #include <unordered_set>
 #include <climits>
 #include "attachments.h"
 #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)
     {
         char buffer[32];
         wcstombs(buffer, value.c_str(), 32);
 
         __value = buffer;
     }
     Atom(std::string && name): __value(name) {}
 
     const std::string&  get() const{return __value; }
 private:
     std::string __value;
 };
 
 template<> class Atom<Number_t>
 {
 public:
     Atom(wchar_t* value)
     {
         __value = wcstol(value, 0, 10);
     }
 
     Atom(int value)
         : __value(value)
     {}
     double get()const {return __value; }
 private:
    double __value;
 };
 
 template<> class Atom<String_t>
 {
 public:
     Atom(const std::wstring& value)
         : __value(++value.begin(), --value.end())
     {}
 
     const std::string& get() const {return __value; }
 
 private:
     std::string __value;
 };
 
 enum class TypePrimitive {Bool, Int, Float, Num, String, I32, I8};
 
 template<> class Atom<Type_t>
 {
 public:
     Atom(wchar_t* value)
     {
         char buffer_[32];
         wcstombs(buffer_, value, 32);
         std::string buffer(buffer_);
 
         if (buffer=="bool"){
             __value = TypePrimitive ::Bool;
         } else if (buffer=="int") {
             __value = TypePrimitive::Int;
         } else if (buffer=="float") {
             __value = TypePrimitive::Float;
         } else if (buffer=="num") {
             __value = TypePrimitive::Num;
         } else if (buffer=="string") {
             __value = TypePrimitive::String;
         }
     }
 
     Atom()
     {
     }
 
     TypePrimitive get() const
     {
         return __value;
     }
 
 private:
     TypePrimitive __value;
 };
 
 typedef Atom<Type_t> TypeAtom;
 
 
 enum class TypeOperator{NONE, CALL, CUSTOM, 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);
     bool operator< (const TypeAnnotation& t) const;
  //   TypeAnnotation (struct_tag, std::initializer_list<TypePrimitive>);
 
 
     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, LSS, GTR, NEG, LIST, LIST_RANGE, LIST_NAMED, CALL, NONE, IMPL/* implication */, MAP, FOLD, INDEX, IF, SWITCH, CASE, LOGIC_AND
 };
 
 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()
     {
         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);
 
 struct Expression
 {
     friend class CodeScope;
     friend class ClaspLayer;
     friend class CFGPass;
 
     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 addBlock(ManagedScpPtr scope);
 
     const std::vector<Expression>& getOperands() const;
     double getValueDouble() const;
     const std::string& getValueString() const;
     void setValue(const Atom<Identifier_t>&& v);
     bool isNone() const;
     bool isValid() const;
 
-    Operator op;
     enum {INVALID, COMPOUND, IDENT, NUMBER, STRING, NONE} __state = INVALID;
+    Operator op;
     std::vector<std::string> bindings;
     std::map<std::string, size_t> __indexBindings;
     std::vector<Expression> operands;
     TypeAnnotation type;
 
     std::map<std::string, Expression> tags;
     std::list<CodeScope*> blocks;
 private:
     std::string __valueS;
     double __valueD;
 
 
 };
 
 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 VID;
 
 
 
 /*
 class Expression: ExpressionAbstract
 {
     friend class CFGPass;
 
 public:
     llvm::Value* compile(LLVMLayer& l, Function* f,  std::string* hintRetVar=0) const;
 };
 */
 
 
 
 typedef std::pair<VID, TypeAnnotation> VariableDefinition;
 typedef std::pair<VID, Expression> VariableDeclaration;
 
 typedef std::pair<Expression, TagModifier> Tag;
 
 
 struct Symbol
 {
     VID identifier;
     CodeScope * scope;
 };
 
 struct SymbolTags_t{};
 
 template<>
 struct AttachmentsDict<SymbolTags_t> {
     typedef std::map<std::string, Expression> Data;
     static const unsigned int key = 2;
 };
 
 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);
     void addDeclaration(const Atom <Identifier_t> &&name, TypeAnnotation &&typ, Expression&& body);
 
     void addArg(Atom <Identifier_t>&& name, TypeAnnotation&& typ);
 
 
         //TODO exclude forceCompile partz
     Symbol findSymbol(const std::string &name);
     static const Expression& findDeclaration(const Symbol& symbol);
     static TypeAnnotation& findDefinition(const Symbol& symbol);
     static bool hasDeclaration(const Symbol& symbol);
 
     ~CodeScope();
 
     std::vector<std::string> __args;
     Expression __body;  //TODO move __body to __declarations[0]
 
     SymbolAttachments attachments;
     std::map<std::string, VID> __vartable;
     /**
     * definition of return type has variable index Zero(0)
     */
     //TODO move __definitions to SymbolsAttachments data
     std::unordered_map<VariableDefinition::first_type, VariableDefinition::second_type> __definitions;
     std::unordered_map<VariableDeclaration::first_type, VariableDeclaration::second_type> __declarations;
 protected:
 
 
 
     VID __vCounter=1;
     CodeScope* __parent;
     std::list<CodeScope*> __storage;
     VID registerVar(std::string&& name, TypeAnnotation &&typ);
 };
 
 class Function
 {
     friend class Expression;
     friend class CodeScope;
     friend class AST;
 
 public:
     Function(const Atom<Identifier_t>& name);
 
     void addArg(Atom <Identifier_t>&& name, TypeAnnotation&& typ);
     void addTag(Expression&& tag, const TagModifier mod);
 
     void setReturnType(const TypeAnnotation& rtyp);
 
     const std::string& getName() const;
     const std::vector<Tag>& getAnnotations() const;
     CodeScope* getEntryScope() const;
     CodeScope* __entry;
     std::string __name;
 private:
 
     std::vector<Tag>  __tags;
 };
 
 
 class ExternData;
 
 struct ExternEntry {
     std::string package;
     std::vector<std::string> headers;
 };
 
 typedef Expanded<TypeAnnotation> ExpandedType;
 
 enum ASTInterface {
 	CFA, DFA, Extern
 };
 
 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);
 
 
     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;
+    std::multimap<ASTInterface, Expression> __interfacesData; //TODO CFA data here.
 
 private:
     std::vector<MetaRuleAbstract*> __rules;
     std::vector<Function*> __functions;
     std::vector<CodeScope*> __scopes;
 
     std::map<std::string, unsigned int> __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);
 
 	private:
 ExpandedType expandType(const TypeAnnotation &t, std::map<std::string, TypeAnnotation> scope,
                       const std::vector<TypeAnnotation> &args = std::vector<TypeAnnotation>()) const;
 
 							// ***** TYPES SECTION END *****
 };
 
     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/clasplayer.cpp b/cpp/src/clasplayer.cpp
index 751e072..c074c43 100644
--- a/cpp/src/clasplayer.cpp
+++ b/cpp/src/clasplayer.cpp
@@ -1,611 +1,623 @@
 #include "clasplayer.h"
 
-#include <clasp/program_builder.h>        // for defining logic programs
-#include <clasp/unfounded_check.h>      // unfounded set checkers
-#include <clasp/model_enumerators.h>  // for enumerating answer sets
-#include <clasp/clasp_facade.h>
-
 #include <iostream>
-#include <clingo/clingocontrol.hh>
 #include "utils.h"
 #include <boost/format.hpp>
 #include <boost/algorithm/string/join.hpp>
+#include <gringo/scripts.hh>
 
 using namespace std;
 
 namespace xreate {
 
     void
     ClaspLayer::printWarnings(std::ostream& out)
     {
         const std::string warningTag = "warning";
 
         auto warningsRange = __model.equal_range(warningTag);
 
         for (auto warning=warningsRange.first; warning!= warningsRange.second; ++warning) {
             unsigned int warningId;
 
             Gringo::Value params;
             std::tie(warningId, params) = parse<unsigned int, Gringo::Value>(warning->second);
 
             cout << "Warning: " << __warnings.at(warningId) << " ";
             params.print(out);
             out<<params;
         }
     }
 
     bool
     ClaspLayer::onModel(Gringo::Model const &model) {
         std::list<std::string> warnings;
         cout << "Model: " << endl;
 
         const string& atomBindVar = Config::get("clasp.bindings.variable");
         const string& atomBindFunc = Config::get("clasp.bindings.function");
 
         for (Gringo::Value atom : model.atoms(Gringo::Model::ATOMS)) {
             atom.print(cout);
             cout <<" | "<< endl;
 
             if (*atom.name() == atomBindVar || *atom.name() == atomBindFunc){
                 string name = *std::get<1>(parse<Gringo::Value, Gringo::Value>(atom)).name();
                 __model.emplace(move(name), move(atom));
                 continue;
             }
 
             __model.emplace(*atom.name(), move(atom));
         }
 
         return true;
     }
 
     list<string>
     multiplyLists(list<list<string>> &&lists) {
         typedef list<string> StringList;
         assert(lists.size());
         StringList result(*lists.begin());
         lists.pop_front();
 
         boost::format concat("%s, %s");
         for (StringList &list: lists) {
             StringList::const_iterator end = result.end();
             for (StringList::iterator expr1I = result.begin(); expr1I != end; ++expr1I) {
                 if (list.size() == 0) continue;
 
                 StringList::const_iterator expr2I = list.begin();
                 for (int expr2No = 0, size = list.size() - 1; expr2No < size; ++expr2No, ++expr1I)
                     result.push_back(str(concat %(*expr1I) %(*expr2I)));
 
                 *expr1I = str(concat %(*expr1I) %(*expr2I));
             }
         }
 
         return result;
     }
 
     void
     ClaspLayer::setCFAData(CFAGraph &&graph) {
     	cfagraph = graph;
     }
 
     void
     ClaspLayer::addDFAData(DFAGraph &&graph)
     {
         dfaData = graph;
         std::set<SymbolPacked> symbols;
         ostream &cout = __partGeneral;
 
         cout << endl << "%\t\tStatic analysis: DFA" << endl;
 
         std::vector<std::pair<SymbolPacked, SymbolPacked>>::iterator i1;
         std::vector<DFGConnection>::iterator i2;
 
-        boost::format format3Args("(%1%, %2%, %3%)");
+        boost::format formatDfaConnection("dfa_connection(%1%, %2%, %3%).");
         boost::format format2Args("(%1%, %2%)");
         for (i1= dfaData.__edges.begin(), i2 = dfaData.__data.begin(); i1!= dfaData.__edges.end(); ++i1, ++i2 )
         {
             string edgeName;
             switch (*i2)
             {
                 case DFGConnection::OPT: edgeName = "opt"; break;
                 case DFGConnection::ALIAS: edgeName = "alias"; break;
                 case DFGConnection::PROTO: edgeName = "proto"; break;
             }
 
-            cout << "dfa_connection"<< (format3Args
-                    %(format2Args %(i1->first.identifier)  %(i1->first.scope))
-                    %(format2Args %(i1->second.identifier) %(i1->second.scope))
-                    %edgeName)
-                    << "." <<endl;
+            cout << formatDfaConnection
+                    %(format2Args %(i1->first.identifier)  %(i1->first.scope)).str()
+                    %(format2Args %(i1->second.identifier) %(i1->second.scope)).str()
+                    %edgeName
+                    << " %" <<getHintForPackedSymbol(i1->first) << " - " << getHintForPackedSymbol(i1->second)
+					<<endl;
 
             symbols.insert(i1->first);
             symbols.insert(i1->second);
         }
 
         boost::format formatBind("bind(%1%, %2%).");
         for (const pair<SymbolPacked, Expression>& tag:  dfaData.__tags)
         {
             for (string variant: compile(tag.second)) {
                 cout << (formatBind
                     % (format2Args %(tag.first.identifier) %(tag.first.scope))
                     % (variant))
+					<< "%" << getHintForPackedSymbol(tag.first)
                     << endl;
             }
 
             symbols.insert(tag.first);
         }
 
         for (const SymbolPacked& s: symbols)
         {
-            cout << "v("  << format2Args % (s.identifier) % arg(s.scope) << ")."<<endl;
+            cout << "v("  << format2Args % (s.identifier) % (s.scope) << ")."
+            		<< " %" << getHintForPackedSymbol(s)
+            		<<endl;
         }
     }
 
     void
     ClaspLayer::involveCFAData() {
         ostream &cout = __partTags;
 		const std::string& atomBinding = Config::get("clasp.bindings.function");
 		const std::string& atomBindingScope = Config::get("clasp.bindings.scope");
 
         	//show function tags
     	int counterTags = 0;
 
         boost::format formatFunction("function(%1%).");
         boost::format formatBind("%1%(%2%, %3%).");
         for (auto function: cfagraph.__nodesFunction.left) {
             cout << formatFunction % (function.second) << std::endl;
 
 
         	for (const auto& tag_: boost::make_iterator_range(cfagraph.__functionTags.equal_range(function.first))){
         		const Tag& tag = tag_.second;
 
                 list<string> tagRaw = compile(tag.first);
 				assert(tagRaw.size() == 1);
 
                 cout << formatBind
                         % (atomBinding)
                         % (function.second)
                         % (tagRaw.front())
                     << endl;
 				++counterTags;
         	}
         }
 
         if (counterTags == 0) {
             cout << "%no tags at all" << endl;
         }
 
         	//show scope tags:
         boost::format formatScope("scope(%1%).");
         for (auto scope: __indexScopes) {
         	//std::string function = scope.first.
             cout << formatScope % scope.second << std::endl;
         }
 
 		counterTags = 0;
-        boost::format formatScopeBind("(%1%(%2%, %3%).");
+        boost::format formatScopeBind("%1%(%2%, %3%).");
 		for (auto entry: cfagraph.__scopeTags) {
 			ScopePacked scopeId = entry.first;
 			const Expression& tag = entry.second;
             list<string> tagRaw = compile(tag);
 			assert(tagRaw.size() == 1);
 
             cout << formatScopeBind % atomBindingScope % scopeId %(tagRaw.front()) << endl;
 			++counterTags;
 		}
 
 		if (counterTags == 0) {
 			cout << "%no tags at all" << endl;
 		}
 
 		cout << endl << "%\t\tStatic analysis: CFA" << endl;
 
         boost::format formatCall("call(%1%, %2%).");
 		for (const auto &relation: cfagraph.__relations) {
 			const ScopePacked scopeFrom = relation.first;
 			const string& functionTo = cfagraph.__nodesFunction.left.at(relation.second);
 
             cout << formatCall % (scopeFrom) % (functionTo) << endl;
 		}
     }
 
     void
     ClaspLayer::addRuleWarning(const RuleWarning &rule) {
         //__partGeneral << rule << endl;
 
         list<string> domains;
         boost::format formatDef("%1%(%2%)");
         std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(domains, domains.begin()),
                 [&formatDef](const std::pair<std::string, DomainAnnotation> &argument) {
                     string domain;
                     switch (argument.second) {
                         case DomainAnnotation::FUNCTION:
                             domain = "function";
                             break;
                         case DomainAnnotation::VARIABLE:
                             domain = "variable";
                             break;
                     }
 
                     return boost::str(formatDef % domain % argument.first);
                 });
 
         list<string> vars;
         std::transform(rule.__args.begin(), rule.__args.end(), std::inserter(vars, vars.begin()),
                 [](const std::pair<std::string, DomainAnnotation> &argument) {
                     return argument.first.c_str();
                 });
 
         list<list<string>> guardsRaw;
         std::transform(rule.__guards.begin(), rule.__guards.end(), std::inserter(guardsRaw, guardsRaw.begin()),
                 [this](const Expression &guard) {
                     return compile(guard);
                 });
 
         const list<string>& guards = multiplyLists(std::move(guardsRaw));
         list<string> &&branches = compileNeg(rule.__condition);
 
         boost::format formatWarning("warning(%1%, (%2%)):- %3%, %4%, %5%.");
         for (const string &guardsJoined: guards)
             for (const string &branch: branches) {
                 unsigned int hook = registerWarning(string(rule.__message));
 
                 __partGeneral  <<  formatWarning
                         %(hook)
                         %(boost::algorithm::join(vars, ", "))
                         %(branch)
                         %(guardsJoined)
                         %(boost::algorithm::join(domains, ", "))
                     <<endl;
             }
     }
 
     std::list<std::string>
     ClaspLayer::compile(const Expression &e) const {
         list<string> result;
 
         switch (e.op) {
             case Operator::CALL: {
                 assert(e.__state == Expression::COMPOUND);
 
                 std::list<list<string>> operands;
                 std::transform(e.operands.begin(), e.operands.end(), std::inserter(operands, operands.begin()),
                         [this](const Expression &e) {
                             return compile(e);
                         });
 
                 list<string> &&operands_ = multiplyLists(std::move(operands));
                 result.push_back(boost::str(boost::format("%1%(%2%)") % (e.__valueS) % (boost::algorithm::join(operands_, ", "))));
                 break;
             }
             case Operator::NEG: {
                 assert(e.operands.size() == 1);
 
                 const Expression &op = e.operands.at(0);
                 list<string> &&rawOp = compile(op);
 
                 assert(rawOp.size() == 1);
                 result.push_back((boost::format("not %1%")%(rawOp.front())).str());
                 break;
             };
 
             case Operator::NONE: {
                 switch (e.__state) {
                     case Expression::IDENT:
                         result.push_back(e.__valueS);
                         break;
 
                     case Expression::NUMBER:
                         result.push_back(to_string(e.__valueD));
                         break;
 
                     default:
                         assert(true);
                 }
                 break;
             }
+
+            default: break;
         }
 
         if (e.isNone()){
              result.push_back(e.__valueS);
         }
 
         assert(result.size());
         return result;
     }
 
     std::list<std::string>
     ClaspLayer::compileNeg(const Expression &e) const {
         list<string> result;
         switch (e.op) {
             case Operator::IMPL: {
                 assert(e.__state == Expression::COMPOUND);
                 assert(e.operands.size() == 2);
                 list<string> operands1 = compile(e.operands.at(0));
                 list<string> operands2 = compile(e.operands.at(1));
 
                 boost::format formatNeg("%1%, not %2%");
                 for (const auto &op1: operands1)
                     for (const auto &op2: operands2) {
                         result.push_back(boost::str(formatNeg %(op1) % (op2)));
                     }
                 break;
             }
             case Operator::NEG: {
                 assert(e.operands.size() == 1);
 
                 const Expression &op = e.operands.at(0);
                 list<string> &&rawOp = compile(op);
 
                 assert(rawOp.size() == 1);
                 result.push_back(rawOp.front());
                 break;
             };
 
             default:
                 assert(true);
         }
 
         return result;
     }
 
     unsigned int
     ClaspLayer::registerWarning(std::string &&message) {
         static int warningId = 0;
         __warnings.emplace(warningId, message);
         return warningId++;;
     }
 
     void
     ClaspLayer::involveImports()    {
         ostream &out = __partGeneral;
 
         for (string fn: ast->__rawImports)
         {
             std::ifstream file(fn);
             if (!file) continue;
 
             while(!file.eof()){
                 string line;
                 std::getline(file, line);
                 out << line << endl;
             }
         }
     }
 
     void
 	ClaspLayer::addRawScript(std::string&& script){
     	__partGeneral << script;
     }
 
     void
     ClaspLayer::run() {
         involveImports();
         involveCFAData();
 
         ostringstream program;
         program << __partTags.str() << __partGeneral.str();
         cout << FYEL(program.str()) << endl;
 
-        const char *argv[] = {nullptr, nullptr};
+        std::vector<char const *> args{"clingo", nullptr};
         DefaultGringoModule moduleDefault;
-        ClingoLib ctl(moduleDefault, 2, argv);
-
-        //prg.add("p", ["t"], "q(t).")
-        Gringo::FWStringVec vars{};
-        ctl.add("base", vars, program.str());
+        Gringo::Scripts scriptsDefault(moduleDefault);
+        ClingoLib ctl(scriptsDefault, 0, args.data());
 
-        //prg.ground([("p", [2])])
-        Gringo::Control::GroundVec vals{std::make_pair("base", Gringo::FWValVec {})};
-        ctl.ground(vals, Gringo::Any());
+        ctl.add("base", {}, program.str());
+        ctl.ground({{"base", {}}}, nullptr);
 
-        //solve
-        Gringo::Control::Assumptions as;
-        Gringo::SolveResult result = ctl.solve(Gringo::Control::ModelHandler([&](Gringo::Model const &model) {
-            return this->onModel(model);
-        }), std::move(as));
+//          solve
+        Gringo::SolveResult result = ctl.solve([this](Gringo::Model const &model) {
+            this->onModel(model);
+            return true;
+        }, {});
 
         if (result == Gringo::SolveResult::SAT) {
             cout << FGRN("SUCCESSFULLY") << endl;
         } else {
             cout << FRED("UNSUCCESSFULLY") << endl;
         }
 
-                // invoke all query plugins to process clasp data
+//      invoke all query plugins to process clasp data
         for (IQuery* q: __queries)
         {
             q->init(this);
         }
     }
 
     ClaspLayer::ClaspLayer() {
     }
 
-    ClaspLayer::ModelRange
+    ClaspLayer::ModelFragment
     ClaspLayer::query(const std::string& atom)
     {
         if (! __model.count(atom)){
             return boost::none;
         }
 
-        return ModelRange(__model.equal_range(atom));
+        return ModelFragment(__model.equal_range(atom));
     }
 
     ScopePacked
 	ClaspLayer::pack(CodeScope* scope) {
     	auto pos = __indexScopes.emplace(scope, __indexScopes.size());
         if (pos.second)
         	__registryScopes.push_back(scope);
 
         return pos.first->second;
     }
 
     SymbolPacked
 	ClaspLayer::pack(const Symbol& symbol, std::string hintSymbolName)
     {
         SymbolPacked result;
 
         result.scope = pack(symbol.scope);
         result.identifier = symbol.identifier;
+        __indexSymbolNameHints.emplace(result, hintSymbolName);
 
         return result;
     }
 
     Symbol
 	ClaspLayer::unpack(const SymbolPacked& symbol)
     {
         return Symbol{symbol.identifier, __registryScopes[symbol.scope]};
     };
 
-
+    std::string
+	ClaspLayer::getHintForPackedSymbol(const SymbolPacked& symbol){
+    	auto result = __indexSymbolNameHints.find(symbol);
+    	return (result == __indexSymbolNameHints.end())? "" : result->second;
+    }
 
 /*
 void AspOutPrinter::reportSolution(const Clasp::Solver&, const Clasp::Enumerator&, bool complete) {
     if (complete) std::cout << "No more models!" << std::endl;
     else          std::cout << "More models possible!" << std::endl;
 }
 
 
 void AspOutPrinter::reportModel(const Clasp::Solver& s, const Clasp::Enumerator&) {
     std::cout << "Model " << s.stats.solve.models << ": \n";
 // get the symbol table from the solver
     const Clasp::AtomIndex& symTab = *s.strategies().symTab;
     for (Clasp::AtomIndex::const_iterator it = symTab.begin(); it != symTab.end(); ++it)
     {
 // print each named atom that is true w.r.t the current assignment
     }
     std::cout << std::endl;
 }
 
 */
 /*****************************************
  *                      CFAGraph
  *****************************************
  */
     void
     CFAGraph::addFunctionNodeTags(const std::string& function, const std::vector<Tag>&tags) {
         unsigned int fid = registerNodeFunction(function);
 
         for (Tag tag: tags){
         	__functionTags.emplace(fid, tag);
         }
     }
 
     void
 	CFAGraph::addScopeNodeTags(const ScopePacked& scope, const std::vector<Expression>& tags){
     	for (Expression tag: tags){
     		__scopeTags.emplace(scope, tag);
     	}
     }
 
     void
 	CFAGraph::addLink(const ScopePacked& scopeFrom, const std::string& functionTo) {
         unsigned int idFuncTo = registerNodeFunction(functionTo);
 
         __relations.emplace(scopeFrom, idFuncTo);
     }
 
     unsigned int
 	CFAGraph::registerNodeFunction(const std::string& fname){
     	auto pos = __nodesFunction.left.insert(make_pair(__nodesFunction.size(), fname));
 
         return pos.first->first;
     }
 
 
 
 /*****************************************
  *                      DFAGraph
  *****************************************
  */
 
     class VisitorAddTag: public boost::static_visitor<>  {
     public:
         void operator()(const SymbolPacked& symbol){
             __graph->__tags.emplace(symbol, move(__tag));
         }
 
         void operator()(SymbolTransient& symbol){
             symbol.tags.push_back(move(__tag));
         }
 
         void operator()(const SymbolInvalid& symbol){
             assert(false && "Undefined behaviour");
         }
 
         VisitorAddTag(DFAGraph* const dfagraph, Expression&& tag):
             __graph(dfagraph), __tag(tag) {}
 
     private:
         DFAGraph* const __graph;
         Expression __tag;
     };
 
     class VisitorAddLink: public boost::static_visitor<>  {
     public:
         void operator()(const SymbolPacked& nodeFrom){
             if (!__graph->linkExists(__nodeTo, nodeFrom))
             {
                 __graph->__edges.emplace_back(__nodeTo, nodeFrom);
                 __graph->__data.push_back(__link);
 
                 DFAGraph::EdgeId eid = __graph->__edges.size()-1;
                 __graph->__outEdges.emplace(nodeFrom, eid);
             }
         }
 
-        void operator()(const SymbolTransient& symbol){
+        void operator()(const SymbolTransient& symbolFrom){
+            if (__link != DFGConnection::ALIAS){
+                assert(false && "Undefined behaviour");
+            }
+
+            for (const Expression& tag: symbolFrom.tags){
+                __graph->__tags.emplace(__nodeTo, tag);
+            }
         }
 
-        void operator()(const SymbolInvalid& symbol){
+        void operator()(const SymbolInvalid&){
+            if (__link == DFGConnection::ALIAS) return;
+            if (__link == DFGConnection::OPT) return;
+
             assert(false && "Undefined behaviour");
         }
 
         VisitorAddLink(DFAGraph* const dfagraph, const SymbolPacked& nodeTo, DFGConnection link):
             __graph(dfagraph), __nodeTo(nodeTo), __link(link) {}
 
     private:
         DFAGraph* const __graph;
         SymbolPacked __nodeTo;
         DFGConnection __link;
     };
 
     bool
     DFAGraph::linkExists(const SymbolPacked& node1, const SymbolPacked& node2)
     {
         auto range = __outEdges.equal_range(node2);
 
         for(std::multimap<SymbolPacked, EdgeId>::iterator edge = range.first; edge != range.second; ++edge)
         {
             if (__edges[edge->second].second == node1)
                 return true;
         }
 
         return false;
     }
 
     void
     DFAGraph::addLink(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link) {
         VisitorAddLink visitor(this, nodeTo, link);
         boost::apply_visitor(visitor, nodeFrom);
     }
 
     void
     DFAGraph::addTag(SymbolNode& node, Expression&& tag) {
         VisitorAddTag visitor(this, move(tag));
         boost::apply_visitor(visitor, node);
     }
 
     bool operator==(const SymbolPacked& s1, const SymbolPacked& s2)
     {
         return s1.identifier == s2.identifier && s1.scope == s2.scope;
     }
 
     bool operator<(const SymbolPacked& s1, const SymbolPacked& s2)
     {
         return  s1.scope < s2.scope  || (s1.scope ==  s2.scope && s1.identifier < s2.identifier);
     }
 
     void ClaspLayer::registerdQuery(IQuery *query) {
         __queries.push_back(query);
     }
 }
diff --git a/cpp/src/clasplayer.h b/cpp/src/clasplayer.h
index 85acd90..c89196a 100644
--- a/cpp/src/clasplayer.h
+++ b/cpp/src/clasplayer.h
@@ -1,200 +1,202 @@
 #ifndef CLASPLAYER_H
 #define CLASPLAYER_H
 
 #include <ast.h>
 
-#include <gringo/control.hh>
+#include <clingo/clingocontrol.hh>
 #include <string>
 #include <climits>
 #include <boost/bimap.hpp>
 #include <boost/optional.hpp>
 #include <list>
 
 namespace xreate {
 
 	typedef unsigned int ScopePacked;
 
     class CFAGraph {
         friend class ClaspLayer;
 
     public:
         void addFunctionNodeTags(const std::string& function, const std::vector<Tag>&tags);
         void addScopeNodeTags(const ScopePacked& scope, const std::vector<Expression>&tags);
         void addLink(const ScopePacked& scopeFrom, const std::string& functionTo);
         //void print(std::ostream &cout) const;
 
     private:
         std::map<ScopePacked, unsigned int> __relations;
         boost::bimap<unsigned int, std::string > __nodesFunction;
         std::multimap<unsigned int, Tag> __functionTags;
         std::multimap<ScopePacked, Expression> __scopeTags;
 
         unsigned int registerNodeFunction(const std::string& fname);
     };
 
 
 
     struct SymbolPacked
     {
         VID identifier;
         ScopePacked scope;
     };
 
     struct SymbolTransient{
     	std::list<Expression> tags;
     };
 
     struct SymbolInvalid{};
 
     typedef boost::variant<SymbolPacked, SymbolTransient, SymbolInvalid> SymbolNode;
 
     bool operator==(const SymbolPacked& s1, const SymbolPacked& s2);
     bool operator<(const SymbolPacked& s1, const SymbolPacked& s2);
 
     enum class DFGConnection{
         ALIAS, OPT, PROTO};
 
     class VisitorAddTag;
     class VisitorAddLink;
 
     class DFAGraph
     {
         friend class ClaspLayer;
         friend class VisitorAddTag;
         friend class VisitorAddLink;
     public:
         void addTag(SymbolNode& node, Expression&& tag);
         void addLink(const SymbolPacked& nodeTo, const SymbolNode& nodeFrom, DFGConnection link);
         bool linkExists(const SymbolPacked& node1, const SymbolPacked& node2);
 
     private:
         typedef unsigned int EdgeId;
         std::vector<std::pair<SymbolPacked, SymbolPacked>> __edges;
         std::multimap<SymbolPacked, EdgeId> __outEdges;
         std::vector<DFGConnection> __data;
         std::multimap<SymbolPacked, Expression> __tags;
     };
 
     class IQuery    {
     public:
         virtual void init(ClaspLayer* clasp)=0;
         virtual ~IQuery() {}
     };
 
     class ClaspLayer {
 
     public:
         AST *ast;
         DFAGraph dfaData;
         CFAGraph cfagraph;
 
         ClaspLayer();
         void registerdQuery(IQuery* query);
         void addFunctionTags(const std::string &function, const std::vector<Tag> &tags);
         void setCFAData(CFAGraph &&graph);
         void addDFAData(DFAGraph &&graph);
         void addRuleWarning(const RuleWarning &rule);
 
         void run();
 
         template<class ...Types>
         static std::tuple<Types...> parse(const Gringo::Value& atom);
 
         typedef std::multimap<std::string, Gringo::Value>::const_iterator ModelIterator;
-        typedef  boost::optional<std::pair<ClaspLayer::ModelIterator, ClaspLayer::ModelIterator>> ModelRange;
-        ModelRange query(const std::string& atom);
+        typedef  boost::optional<std::pair<ClaspLayer::ModelIterator, ClaspLayer::ModelIterator>> ModelFragment;
+        ModelFragment query(const std::string& atom);
 
         ScopePacked pack(CodeScope* scope);
         SymbolPacked pack(const Symbol& symbol, std::string hintSymbolName="");
         Symbol unpack(const SymbolPacked& symbol);
+        std::string getHintForPackedSymbol(const SymbolPacked& symbol);
         void addRawScript(std::string&& script);
     private:
         // all query plugins to process clasp data
         std::list<IQuery*> __queries;
         std::multimap<std::string, Gringo::Value> __model;
         std::map<unsigned int, std::string> __warnings;
         std::ostringstream __partTags;
         std::ostringstream __partGeneral;
+        std::map<SymbolPacked, std::string> __indexSymbolNameHints;
 
         std::unordered_map<const CodeScope*, unsigned int> __indexScopes;
         std::vector<CodeScope*> __registryScopes;
 
         void printWarnings(std::ostream& out);
         bool onModel(Gringo::Model const &model);
         std::list<std::string> compile(const Expression &e) const;
         std::list<std::string> compileNeg(const Expression &e) const;
         unsigned int registerWarning(std::string &&message);
         void involveImports();
         void involveCFAData();
 
 
     };
 
     template<class typ>
     struct ParseImplAtom {
         static typ get(const Gringo::Value& atom)
         {
             return atom.num();
         }
     };
 
     template<>
     struct ParseImplAtom<std::string> {
         static std::string get(const Gringo::Value& atom)
         {
             return *atom.string();
         }};
 
     template<>
     struct ParseImplAtom<SymbolPacked> {
         static SymbolPacked get(const Gringo::Value& atom)
         {
             auto result = ClaspLayer::parse<unsigned int, unsigned int>(atom);
             return SymbolPacked{std::get<0>(result), std::get<1>(result)};
         }};
 
     template<>
     struct ParseImplAtom<Gringo::Value> {
         static Gringo::Value get(const Gringo::Value& atom)
         {
             return atom;
         }};
 
     template<class Tuple, size_t index>
     struct Parse_Impl {
         static void parse(Tuple& tup, Gringo::FWValVec::const_iterator arg)
         {
             const size_t tupleSize = std::tuple_size<Tuple>::value;
             typedef typename std::tuple_element<tupleSize - index, Tuple>::type ElType;
 
             ElType&  el = std::get<tupleSize - index>(tup);
 
             Gringo::Value atom = *arg;
             el = ParseImplAtom<ElType>::get(atom);
 
             Parse_Impl<Tuple, index-1>::parse(tup, ++arg);
         }
     };
 
     template<class Tuple>
     struct Parse_Impl<Tuple, 0>
     {
         static void parse(Tuple& tup, Gringo::FWValVec::const_iterator arg)
         {}
     };
 
 
     template<class ...Types>
     std::tuple<Types...>
     ClaspLayer::parse(const Gringo::Value& atom)
     {
         typedef std::tuple<Types...> Tuple;
         Tuple tup;
         Parse_Impl<Tuple, std::tuple_size<Tuple>::value>::parse(tup, atom.args().begin());
 
         return tup;
     }
 
 
 }
 #endif
diff --git a/cpp/src/instructions/instr-containers.cpp b/cpp/src/instructions/instr-containers.cpp
index 5f7bfbc..793aec7 100644
--- a/cpp/src/instructions/instr-containers.cpp
+++ b/cpp/src/instructions/instr-containers.cpp
@@ -1,470 +1,501 @@
 #include "instr-containers.h"
 #include "llvmlayer.h"
 #include "ast.h"
 #include "query/containers.h"
 #include "query/ptrvalid.h"
 
 using namespace std;
 using namespace llvm;
 using namespace xreate;
 using namespace xreate::containers;
 
 #define NAME(x) (hintRetVar.empty()? x : hintRetVar)
-
+#define UNUSED(x) (void)(x)
 #define EXPAND_CONTEXT         \
     LLVMLayer* llvm = context.pass->man->llvm; \
     CompilePass::CodeScopeUnit* scope = context.scope; \
     CompilePass::FunctionUnit* function = context.function; \
 
 Instructions::Instructions(CompilePass::Context ctx)
       : context(ctx), tyNum (static_cast<llvm::IntegerType*> (ctx.pass->man->llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::Num)))))
 {}
 
 llvm::Value*
 Instructions::compileMapSolid(const Expression &expr, const std::string hintRetVar) {
         EXPAND_CONTEXT
 
                 //initialization
         std::string varIn = expr.getOperands()[0].getValueString();
         Symbol symbolIn = scope->scope->findSymbol(varIn);
 
         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->__args[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);
     CompilePass::CodeScopeUnit* 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, blockLoop);
 
                 //next iteration checks:
     Value* condAfter = builder.CreateICmpSLE(stateLoopNext, rangeTo);
     builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);
 
                 //finalization:
     builder.SetInsertPoint(blockAfterLoop);
 
     return dataOut;
 }
 
 Value*
 Instructions::compileArrayIndex(const Symbol &dataSymbol, std::vector<llvm::Value *> indexes, std::string hintRetVar)
 {
     EXPAND_CONTEXT
+    UNUSED(function);
 
     //TODO find out symbol identifier in order to name it in raw llvm;
     llvm::Value* data = scope->compileSymbol(dataSymbol);
     const Expression& decl = CodeScope::findDeclaration(dataSymbol);
 
     if (decl.op == Operator::LIST) {
         assert(indexes.size() == 1);
         return llvm->builder.CreateExtractElement(data, indexes[0], NAME("el"));
     }
 
 
     indexes.insert(indexes.begin(), llvm::ConstantInt::get(tyNum, 0));
     Value *pEl = llvm->builder.CreateGEP(data, llvm::ArrayRef<llvm::Value *>(indexes));
     return llvm->builder.CreateLoad(pEl, NAME("el"));
 }
 
 Value*
 Instructions::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);
 
 
 					// safety check: not null ptr
 			Symbol s;
 			if (! QueryPtrValid::assertValidPtr(s)){
 				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");
 }
 
 llvm::Value*
 Instructions::compileFold(const Expression& fold, const std::string& hintRetVar)
 {
     EXPAND_CONTEXT
     assert(fold.op == Operator::FOLD);
 
             //initialization:
     Symbol varInSymbol  = scope->scope->findSymbol(fold.getOperands()[0].getValueString());
     Implementation info = Query::queryImplementation(varInSymbol);
 
     Iterator* it = Iterator::create(context, varInSymbol);
     llvm::Value* rangeFrom = it->begin();
     llvm::Value* rangeTo = 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::Value* valSat;
+    llvm::Value* valSat = nullptr;
     bool flagHasSaturation = false; //false; // TODO add `saturation` ann.
 
     llvm::BasicBlock *blockBeforeLoop = llvm->builder.GetInsertBlock();
     llvm::BasicBlock *blockLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "fold", function->raw);
     llvm::BasicBlock *blockAfterLoop = llvm::BasicBlock::Create(llvm::getGlobalContext(), "postfold", function->raw);
     llvm::BasicBlock *blockEarly = llvm::BasicBlock::Create(llvm::getGlobalContext(), "earlyret", function->raw);
 
 
 
             // * initial check
     Value* condBefore = llvm->builder.CreateICmpNE(rangeFrom, rangeTo);
     llvm->builder.CreateCondBr(condBefore, blockLoop, blockEarly);
     llvm->builder.SetInsertPoint(blockEarly);
     llvm->builder.CreateRet(accumInit);
 
+            //TODO implement saturation; add unittests;
     		// Saturation check
     if (flagHasSaturation)
     {
         Value* condSat = llvm->builder.CreateICmpNE(accumInit, valSat);
         llvm->builder.CreateCondBr(condSat, blockLoop, blockAfterLoop);
     }
 
             // * create phi
     llvm->builder.SetInsertPoint(blockLoop);
     llvm::PHINode *accum = llvm->builder.CreatePHI(tyNum, 2, NAME("accum"));
     accum->addIncoming(accumInit, blockBeforeLoop);
     llvm::PHINode *stateLoop = llvm->builder.CreatePHI(rangeFrom->getType(), 2, "foldIt");
     stateLoop->addIncoming(rangeFrom, blockBeforeLoop);
 
             // * loop body
     CodeScope* scopeLoop = fold.blocks.front();
     CompilePass::CodeScopeUnit* loopUnit = function->getScopeUnit(scopeLoop);
     Value* elIn = it->get(stateLoop);
     loopUnit->bindArg(accum, move(varAccum));
     loopUnit->bindArg(elIn, move(varEl));
     Value* accumNext = loopUnit->compile();
 
             // * break checks, continue checks
     if (flagHasSaturation)
     {
         llvm::BasicBlock *blockChecks = llvm::BasicBlock::Create(llvm::getGlobalContext(), "checks", function->raw);
         Value* condSat = llvm->builder.CreateICmpNE(accumNext, valSat);
         llvm->builder.CreateCondBr(condSat, blockChecks, blockAfterLoop);
         llvm->builder.SetInsertPoint(blockChecks);
     }
             // * computing next iteration state
     Value *stateLoopNext = it->move(stateLoop);
     accum->addIncoming(accumNext,  llvm->builder.GetInsertBlock());
     stateLoop->addIncoming(stateLoopNext, llvm->builder.GetInsertBlock());
 
              // * next iteration checks
     Value* condAfter = llvm->builder.CreateICmpNE(stateLoopNext, rangeTo);
     llvm->builder.CreateCondBr(condAfter, blockLoop, blockAfterLoop);
 
             // finalization:
     llvm->builder.SetInsertPoint(blockAfterLoop);
 
     return accum;
 }
 
 llvm::Value*
 Instructions::compileIf(const Expression& exprIf, const std::string& hintRetVar)
 {
     EXPAND_CONTEXT
 
            //initialization:
     const Expression& condExpr = exprIf.getOperands()[0];
     llvm::IRBuilder<>& builder = llvm->builder;
 
     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();
     builder.CreateBr(blockAfter);
 
     builder.SetInsertPoint(blockFalse);
     CodeScope* scopeFalse = exprIf.blocks.back();
     llvm::Value* resultFalse = function->getScopeUnit(scopeFalse)->compile();
     builder.CreateBr(blockAfter);
 
     builder.SetInsertPoint(blockAfter);
     llvm::PHINode *ret =  builder.CreatePHI(tyNum, 2, NAME("if"));
     ret->addIncoming(resultTrue, blockTrue);
     ret->addIncoming(resultFalse, blockFalse);
 
     return ret;
 }
 
+
+//TODO implement switch
 llvm::Value*
 Instructions::compileSwitch(const Expression& exprSwitch, const std::string& hintRetVar){
 	EXPAND_CONTEXT
-    llvm::IRBuilder<>& builder = llvm->builder;
-
+    UNUSED(scope);
+    UNUSED(function);
+    UNUSED(llvm);
+    return nullptr;
 
+    //llvm::IRBuilder<>& builder = llvm->builder;
 	//builder.CreateSwitch()
-
 }
 
 llvm::Value*
 Instructions::compileConstantArray(const Expression &expr, const std::string& hintRetVar) {
     EXPAND_CONTEXT
+    UNUSED(scope);
+    UNUSED(function);
 
     const size_t& __size = expr.getOperands().size();
     const Expression& __data = expr;
 
     ArrayType* typList = (ArrayType*) (llvm->toLLVMType(ExpandedType(TypeAnnotation(tag_array, TypePrimitive::I32, __size))));
     Type*typI32 = llvm->toLLVMType(ExpandedType(TypeAnnotation(TypePrimitive::I32)));
 
     std::vector<Constant *> list;
     list.reserve(__size);
 
     const std::vector<Expression> operands = __data.getOperands();
     std::transform(operands.begin(), operands.end(), std::inserter(list, list.begin()),
         [typI32](const Expression& e){return ConstantInt::get(typI32, e.getValueDouble());});
 
     Value* listSource = ConstantArray::get(typList, ArrayRef<Constant*>(list));
         /*
     Value* listDest = l.builder.CreateAlloca(typList, ConstantInt::get(typI32, __size), *hintRetVar);
     l.buil1der.CreateMemCpy(listDest, listSource, __size, 16);
         */
 
     return listSource;
 }
 
 llvm::Value*
 Instructions::compileConstantStringAsPChar(const string& data, const std::string& hintRetVar)
 {
     EXPAND_CONTEXT
+    UNUSED(function);
+    UNUSED(scope);
 
-    size_t size = data.size();
     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);
 }
 
 
 
 template<ImplementationType I>
 class IteratorForward;
 
 template<>
 class IteratorForward<ON_THE_FLY> : public Iterator {
 private:
     LLVMLayer* llvm;
     const xreate::Symbol current;
     const Symbol source;
     const ImplementationLinkedList linkedlist;
     CodeScope* const sourceScope;
             //TODO initialize ans mark as const (three fields)
     CompilePass::CodeScopeUnit* sourceUnit;
-    CompilePass::FunctionUnit* function;
+    CompilePass::FunctionUnit* function; //TODO is used somewhere?
     const Expression& sourceDecl;
     CompilePass::Context context;
     llvm::Type* sourceRawType =nullptr;
 
 public:
     IteratorForward(CompilePass::Context ctx, const xreate::Symbol& s, const ImplementationRec<ON_THE_FLY>& implementation)
-        : context(ctx), source(implementation.source), current(s), sourceScope(source.scope), sourceDecl(CodeScope::findDeclaration(source)),
-            linkedlist(source), sourceUnit(new CompilePass::CodeScopeUnit(source.scope, ctx.function, ctx.pass)), llvm(ctx.pass->man->llvm)
+        : llvm(ctx.pass->man->llvm), current(s), source(implementation.source), linkedlist(source), sourceScope(source.scope), sourceUnit(new CompilePass::CodeScopeUnit(source.scope, ctx.function, ctx.pass)),
+        sourceDecl(CodeScope::findDeclaration(source)),
+        context(ctx)
     {
     }
 
     llvm::Value* begin() {
         switch(sourceDecl.op) {
             case xreate::Operator::LIST:
             {
             	sourceRawType = Type::getInt32Ty(llvm::getGlobalContext());
                 return ConstantInt::get(Type::getInt32Ty(llvm::getGlobalContext()), 0);
             };
 
             case xreate::Operator::LIST_RANGE:{
                 assert(sourceDecl.operands.size()==2);
 
                 llvm::Value* result = sourceUnit->process(sourceDecl.operands.at(0));
                 sourceRawType = result->getType();
 
                 return result;
             };
+
+        default: break;
         }
 
         if (linkedlist){
             llvm::Value* result = sourceUnit->process(sourceDecl);
             sourceRawType = result->getType();
            return result;
         }
 
         assert(false);
     }
 
     llvm::Value* end(){
         switch(sourceDecl.op) {
             case xreate::Operator::LIST: {
                 size_t idLast = sourceDecl.operands.size() - 1;
                 return ConstantInt::get(sourceRawType, idLast);
             }
 
             case xreate::Operator::LIST_RANGE: {
                 assert(sourceDecl.operands.size() == 2);
                 return sourceUnit->process(sourceDecl.operands.at(1));
             };
+
+        default: break;
         }
 
                     //return null pointer
         if (linkedlist){
         	return ConstantPointerNull::getNullValue(sourceRawType);
         }
+
+        assert(false && "Unknown declaration");
+        return nullptr;
     }
 
     llvm::Value* get(Value* index,const std::string& hintRetVar="") override{
         const Expression& currentDecl = CodeScope::findDeclaration(current);
 
         switch (currentDecl.op) {
             case xreate::Operator::LIST:             {
-                llvm::Value* currentValue = sourceUnit->process(currentDecl);   //TODO re check is it right scope(source) to compilation currentDecl
+                //TODO re check is it right scope(source) to compilation currentDecl. Write unittests for this.
+                //llvm::Value* currentValue = sourceUnit->process(currentDecl);
                 return Instructions(context).compileArrayIndex(current, vector<Value *>{index});
             };
 
             case xreate::Operator::LIST_RANGE: {
                 return index;
             };
 
             case xreate::Operator::MAP:             {
                 assert(currentDecl.getOperands().size()==1);
                 assert(currentDecl.bindings.size());
                 assert(currentDecl.blocks.size());
 
                 CodeScope* scopeLoop = currentDecl.blocks.front();
                 const std::string& varIn = currentDecl.getOperands()[0].getValueString();
                 std::string varEl = currentDecl.bindings[0];
 
                 const Symbol& symbIn =  current.scope->findSymbol(varIn);
                 auto it = std::unique_ptr<Iterator>(Iterator::create(context, symbIn));
 
                 Value* elIn = it->get(index, varEl);
                 CompilePass::CodeScopeUnit* unitLoop = function->getScopeUnit(scopeLoop);
                 unitLoop->bindArg(elIn, std::move(varEl));
                 return unitLoop->compile();
             }
 
             case xreate::Operator::NONE: {
                 assert(currentDecl.__state==Expression::IDENT);
                 const Symbol& symbIn =  current.scope->findSymbol(currentDecl.getValueString());
                 auto it = std::unique_ptr<Iterator>(Iterator::create(context, symbIn));
                 return it->get(index);
             };
+
+            default: break;
         }
 
         if (linkedlist){
             return index;
         }
+
+        assert(false && "Unknown declaration");
+        return nullptr;
     }
 
     llvm::Value* move(Value* index, const std::string& hintRetVar) override{
         switch(sourceDecl.op)
         {
             case xreate::Operator::LIST:
             case xreate::Operator::LIST_RANGE:
                 return llvm->builder.CreateAdd(index, llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), 1), hintRetVar);
+
+            default: break;
         }
 
         if (linkedlist){
             ExpandedType tySource = llvm->ast->expandType(sourceScope->findDefinition(source));
             assert(tySource->__operator == TypeOperator::ARRAY && "Linked list implementation has to have ARRAY type");
             assert(tySource->__operands.size());
 
             return Instructions(context).compileStructIndex(index, ExpandedType(TypeAnnotation(tySource->__operands.at(0))), linkedlist.fieldPointer);
         }
+
+        assert(false && "Unknown declaration");
+        return nullptr;
     }
 };
 
 Iterator*
 Iterator::create(CompilePass::Context context, const Symbol& var){
 
     const Implementation& data = Query::queryImplementation(var);
 
     switch(data.impl){
         case ON_THE_FLY:
             return new IteratorForward<ON_THE_FLY>(context, var, data.extract<ON_THE_FLY>());
 
         default: assert(true);
     }
+
+    assert(false && "Unknown declaration");
+    return nullptr;
 }
diff --git a/cpp/src/llvmlayer.cpp b/cpp/src/llvmlayer.cpp
index 2afa47c..0e34bb4 100644
--- a/cpp/src/llvmlayer.cpp
+++ b/cpp/src/llvmlayer.cpp
@@ -1,249 +1,246 @@
 #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>
 
 using namespace llvm;
 using namespace xreate;
 using namespace std;
 
 LLVMLayer::LLVMLayer(AST* root)
-    :builder(getGlobalContext()), 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::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::I8:
                     return llvm::Type::getInt8Ty(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;
 
-    const clang::PointerType* tPtr = raw->getAs<clang::PointerType>();
     clang::QualType pointee = raw->getPointeeType();
-    const clang::Type * pointeeRaw = pointee.getTypePtr();
     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/abstractpass.cpp b/cpp/src/pass/abstractpass.cpp
index 8ca4dc2..7eac8f0 100644
--- a/cpp/src/pass/abstractpass.cpp
+++ b/cpp/src/pass/abstractpass.cpp
@@ -1,15 +1,36 @@
 #include "abstractpass.h"
 #include "attachments.h"
 #include "passmanager.h"
 
 using namespace std;
 
 namespace xreate {
 
+    template<>
+    void defaultValue(){};
+
     void AbstractPassBase::finish()
     {}
 
     AbstractPassBase::AbstractPassBase(PassManager *manager)
             : man(manager) {
     }
+
+    template<>
+    void
+    AbstractPass<void>::processSymbol(const std::string& ident, PassContext context)
+    {
+        const Symbol& symbol = context.scope->findSymbol(ident);
+
+        if (__visitedSymbols.isCached(symbol))
+            return;
+
+        if (CodeScope::hasDeclaration(symbol)) {
+        	__visitedSymbols.setCachedValue(symbol);
+
+            PassContext context2 = context;
+            context2.scope = symbol.scope;
+            process(CodeScope::findDeclaration(symbol), context2, ident);
+        }
+    }
 }
diff --git a/cpp/src/pass/abstractpass.h b/cpp/src/pass/abstractpass.h
index da48e1c..81667b4 100644
--- a/cpp/src/pass/abstractpass.h
+++ b/cpp/src/pass/abstractpass.h
@@ -1,123 +1,169 @@
 #ifndef ABSTRACTPASS_H
 #define ABSTRACTPASS_H
 #include "ast.h"
 #include "passmanager.h"
 
 #include<iostream>
 using namespace std;
 namespace xreate
 {
     struct PassContext
     {
         CodeScope* scope = 0;
         ManagedFnPtr function;
         ManagedRulePtr rule;
         std::string varDecl;
 
         PassContext()
         {}
 
         PassContext&& updateScope(CodeScope* scopeNew) {
             PassContext context2{*this};
             context2.scope = scopeNew;
             return std::move(context2);
         }
 
         ~PassContext(){}
     };
 
     class PassManager;
 
     class AbstractPassBase {
     public:
         AbstractPassBase(PassManager* manager);
         virtual void run()=0;
         virtual void finish();
 
         PassManager* man;
     };
 
+    template<class Output>
+    Output defaultValue();
+
+    template<class Output>
+    class SymbolCache: private std::map<Symbol, Output>{
+        public:
+            bool isCached(const Symbol& symbol){
+                return this->count(symbol);
+            }
+
+            Output setCachedValue(const Symbol& symbol, Output&& value){
+                this->emplace(symbol, value);
+                return value;
+            }
+
+            Output getCachedValue(const  Symbol& symbol){
+                assert(this->count(symbol));
+                return this->at(symbol);
+            }
+    };
+
+    template<>
+    class SymbolCache<void>: private std::set<Symbol>{
+        public:
+        bool isCached(const Symbol& symbol){
+            bool result = this->count(symbol) > 0;
+            return result;
+        }
+        void setCachedValue(const Symbol& symbol){
+            this->insert(symbol);
+        }
+
+        void getCachedValue(const  Symbol& symbol){
+        }
+    };
+
     template<class Output>
     class AbstractPass: public AbstractPassBase    {
     private:
-        std::set<Symbol> __visitedSymbols;
-        Output __defaultValue;
+        SymbolCache<Output> __visitedSymbols;
+
+        Output processSymbol(const std::string& ident, PassContext context){
+            const Symbol& symbol = context.scope->findSymbol(ident);
+
+            if (__visitedSymbols.isCached(symbol))
+                return __visitedSymbols.getCachedValue(symbol);
 
+            if (CodeScope::hasDeclaration(symbol)) {
+                PassContext context2 = context;
+                context2.scope = symbol.scope;
+                Output&& result = process(CodeScope::findDeclaration(symbol), context2, ident);
+                return __visitedSymbols.setCachedValue(symbol, std::move(result));
+            }
+
+            return defaultValue<Output>();
+        }
     public:
-        AbstractPass(PassManager* manager, Output defaultValue=Output())
-            : AbstractPassBase(manager), __defaultValue(defaultValue) {}
+        AbstractPass(PassManager* manager)
+            : AbstractPassBase(manager){}
 
             //NOTE implement processFnCall
         virtual void processFnCall(ManagedFnPtr function, PassContext context)
             {}
 
         virtual void process(ManagedRulePtr rule)
             {}
 
         virtual Output process(ManagedFnPtr function){
             PassContext context;
             context.function = function;
 
             return process(function->getEntryScope(), context);
         }
 
         virtual Output process(CodeScope* scope, PassContext context, const std::string& hintBlockDecl=""){
             context.scope = scope;
             return process(scope->__body, context);
         }
 
         virtual Output process(const Expression& expression, PassContext context, const std::string& varDecl=""){
             switch (expression.__state) {
                 case Expression::COMPOUND:
-                assert(expression.op != Operator::MAP || expression.op == Operator::MAP && expression.blocks.size());
+                assert(expression.op != Operator::MAP || (expression.op == Operator::MAP && expression.blocks.size()));
 
                 for (const Expression &op: expression.getOperands()) {
                     process(op, context);
                 }
 
                 for (CodeScope* scope: expression.blocks) {
                     process(scope, context);
                 }
 
                 if (expression.op == Operator::CALL) {
                     const std::string &calleeName = expression.getValueString();
                     ManagedFnPtr callee = man->root->findFunction(calleeName);
                     if (callee) processFnCall(callee, context);
                 }
                 break;
 
                 case Expression::IDENT:
                     assert(context.scope);
+                    return processSymbol(expression.getValueString(), context);
 
-                    std::string ident = expression.getValueString();
-                    const Symbol& symbol = context.scope->findSymbol(ident);
-
-                    if (__visitedSymbols.count(symbol)) {assert(false && "Invalid state");}
-                    __visitedSymbols.insert(symbol);
-
-                    PassContext context2 = context;
-                    context2.scope = symbol.scope;
-                    if (CodeScope::hasDeclaration(symbol)) {
-                       return process(CodeScope::findDeclaration(symbol), context2, ident);
-                    }
-
-                    break;
+                default:
+                break;
             }
+
+            return defaultValue<Output>();
         }
 
         void run() {
             ManagedRulePtr rule = man->root->begin<MetaRuleAbstract>();
             while (rule.isValid()) {
                 process(rule);
                 ++rule;
             }
 
             ManagedFnPtr f = man->root->begin<Function>();
             while (f.isValid()) {
                 process(f);
                 ++f;
             }
         }
     };
+
+    template<>
+    void
+    AbstractPass<void>::processSymbol(const std::string& ident, PassContext context);
 }
 #endif
diff --git a/cpp/src/pass/compilepass.cpp b/cpp/src/pass/compilepass.cpp
index ed0d8b2..0fde4db 100644
--- a/cpp/src/pass/compilepass.cpp
+++ b/cpp/src/pass/compilepass.cpp
@@ -1,454 +1,457 @@
 #include "compilepass.h"
 #include "clasplayer.h"
 #include <ast.h>
 #include <iostream>
 #include "query/containers.h"
 #include "instructions/instr-containers.h"
 #include "ExternLayer.h"
 
 using namespace std;
 using namespace xreate;
 using namespace llvm;
 
 CompilePass::CodeScopeUnit::CodeScopeUnit(CodeScope* codeScope, FunctionUnit* f, CompilePass* compilePass)
     : scope(codeScope), pass(compilePass), function(f)
 {}
 
 void
 CompilePass::CodeScopeUnit::bindArg(llvm::Value* var, std::string&& name)
 {
     assert(scope->__vartable.count(name));
     VID id = scope->__vartable.at(name);
     __rawVars[id] = var;
 }
 
 llvm::Value*
 CompilePass::CodeScopeUnit::convertType(llvm::Value* source, llvm::Type* tyTarget){
 	LLVMLayer* llvm = pass->man->llvm;
 
 	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 llvm->builder.CreateCast(llvm::Instruction::Trunc, source, tyTarget);
 		}
 
 		if (tyTargetInt->getBitWidth() > tySourceInt->getBitWidth()){
 			return llvm->builder.CreateCast(llvm::Instruction::SExt, source, tyTarget);
 		}
 	}
 
 	assert(false && "no automatic type conversion possible");
 }
 
 llvm::Value*
 CompilePass::CodeScopeUnit::process(const Expression& expr, const std::string& hintVarDecl){
 #define VARNAME(x) (hintVarDecl.empty()? x: hintVarDecl)
     llvm::Value *left; llvm::Value *right;
     LLVMLayer& l = *pass->man->llvm;
     CompilePass::Context context{function, this, pass};
     containers::Instructions instructions = containers::Instructions(context);
 
     switch (expr.op) {
         case Operator::ADD:
         case Operator::SUB:
         case Operator::MUL:
         case Operator::DIV:
         case Operator::EQU:
         case Operator::LSS:
         case Operator::GTR:
             assert(expr.__state == Expression::COMPOUND);
             assert(expr.operands.size() == 2);
 
             left = process(expr.operands[0]);
             right = process(expr.operands[1]);
 
             if (left->getType()!= right->getType()) {
             	right =	convertType(right, left->getType());
             }
             break;
 
         default:;
     }
 
     switch (expr.op) {
         case Operator::ADD:
             return l.builder.CreateAdd(left, right, VARNAME("tmp_add"));
             break;
 
         case Operator::SUB:
             return l.builder.CreateSub(left, right, VARNAME("tmp_sub"));
             break;
 
         case Operator::MUL:
             return l.builder.CreateMul(left, right, VARNAME("tmp_mul"));
             break;
 
         case Operator::DIV:
             return l.builder.CreateSDiv(left, right, VARNAME("tmp_div"));
             break;
 
         case Operator::EQU:
             left->dump();
             right->dump();
             return l.builder.CreateICmpEQ(left, right, VARNAME("tmp_equ"));
             break;
 
         case Operator::LSS:
             return l.builder.CreateICmpSLT(left, right, VARNAME("tmp_lss"));
             break;
 
         case Operator::GTR:
             return l.builder.CreateICmpSGT(left, right, VARNAME("tmp_gtr"));
             break;
 
         case Operator::NEG:
             left = process(expr.operands[0]);
             return l.builder.CreateNeg(left, VARNAME("tmp_neg"));
             break;
 
         case Operator::CALL: {
             assert(expr.__state == Expression::COMPOUND);
 
             std::string fname = expr.getValueString();
 
 
             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);
                     }
             );
 
             FunctionUnit* calleeUnit = pass->getFunctionUnit(string(fname));
 
             	// external function
             if (!calleeUnit) {
             	llvm::Function* external = pass->man->llvm->layerExtern->lookupFunction(fname);
             	return l.builder.CreateCall(external, args, hintVarDecl);
             }
 
             if (calleeUnit->isInline()) {
                 return calleeUnit->compileInline(move(args), this->function);
             }
 
             llvm::BasicBlock* blockPrev = pass->man->llvm->builder.GetInsertBlock();
             llvm::Value* callee = calleeUnit->compile();
             pass->man->llvm->builder.SetInsertPoint(blockPrev);
             return l.builder.CreateCall(callee, args, hintVarDecl);
         }
 
         case Operator::IF:
         {
         	return instructions.compileIf(expr, hintVarDecl);
         }
 
         case Operator::SWITCH:
         {
         	return nullptr; //instructions.compileSwitch();
         }
 
         case Operator::LIST:
         {
            return instructions.compileConstantArray(expr, hintVarDecl);
         };
 
         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 (int i=0; i<expr.operands.size(); ++i){
+            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;
 
                 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.compileMapSolid(expr, VARNAME("map"));
         };
 
         case Operator::FOLD:
         {
             return instructions.compileFold(expr, VARNAME("fold"));
         };
 
         case Operator::INDEX:
         {
                 //TODO allow multiindex
             assert(expr.operands.size()==1);
             const std::string &ident = expr.getValueString();
             Symbol s = scope->findSymbol(ident);
             const TypeAnnotation& t = s.scope->findDefinition(s);
             const ExpandedType& t2 = pass->man->root->expandType(t);
 
             switch (t2.get().__operator)
             {
                 case TypeOperator::STRUCT: case TypeOperator::CUSTOM:
                 {
                     Expression idx = expr.operands.at(0);
                     assert(idx.__state == Expression::STRING);
                     std::string idxField = idx.getValueString();
 
                     llvm::Value* aggr  = compileSymbol(s, ident);
                     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(s, indexes, VARNAME(string("el_") + ident));
                 };
 
                 default:
                     assert(false);
             }
         };
 
 
         case Operator::NONE:
             assert(expr.__state != Expression::COMPOUND);
 
             switch (expr.__state) {
                 case Expression::IDENT: {
                     const std::string &ident = expr.getValueString();
                     Symbol s = scope->findSymbol(ident);
                     return compileSymbol(s, ident);
                 }
 
                 case Expression::NUMBER: {
                     int literal = expr.getValueDouble();
                     return llvm::ConstantInt::get(llvm::Type::getInt32Ty(llvm::getGlobalContext()), literal);
                 }
 
                 case Expression::STRING: {
                     return instructions.compileConstantStringAsPChar(expr.getValueString(), hintVarDecl);
                 };
 
-
+                default: {
+                    break;
+                }
             };
 
             break;
 
+        default: break;
+
     }
 
     assert(false);
     return 0;
 }
 
 llvm::Value*
 CompilePass::CodeScopeUnit::compile(const std::string& hintBlockDecl){
     if (raw != nullptr) return raw;
 
 
     if (!hintBlockDecl.empty()) {
         llvm::BasicBlock *block = llvm::BasicBlock::Create(llvm::getGlobalContext(), hintBlockDecl, function->raw);
         pass->man->llvm->builder.SetInsertPoint(block);
     }
 
     raw = process(scope->__body);
     return raw;
 }
 
 llvm::Value*
 CompilePass::CodeScopeUnit::compileSymbol(const Symbol& s, std::string hintRetVar)
 {
     CodeScope* scope = s.scope;
     CodeScopeUnit* self = function->getScopeUnit(scope);
 
     if (self->__rawVars.count(s.identifier))     {
         return self->__rawVars[s.identifier];
     }
 
     return self->__rawVars[s.identifier] = self->process(scope->findDeclaration(s), hintRetVar);
 }
 
 bool
 CompilePass::FunctionUnit::isInline(){
     Symbol ret = Symbol{0, function->__entry};
     bool flagOnTheFly = SymbolAttachments::get<IsImplementationOnTheFly>(ret, false);
 
     return flagOnTheFly;
 }
 
 llvm::Function*
 CompilePass::FunctionUnit::compile(){
     if (raw != nullptr) return raw;
 
     std::vector<llvm::Type *> types;
     LLVMLayer* llvm = pass->man->llvm;
     CodeScope* entry = function->__entry;
 
     std::transform(entry->__args.begin(), entry->__args.end(), std::inserter(types, types.end()),
             [this, llvm, entry](const std::string &arg)->llvm::Type* {
                 assert(entry->__vartable.count(arg));
                 VID argid = entry->__vartable.at(arg);
                 assert(entry->__definitions.count(argid));
                 return llvm->toLLVMType(pass->man->root->expandType(entry->__definitions.at(argid)));
             });
 
     llvm::FunctionType *ft = llvm::FunctionType::get(llvm->toLLVMType(pass->man->root->expandType(entry->__definitions[0])), types, false);
     raw = llvm::cast<llvm::Function>(llvm->module->getOrInsertFunction(function->__name, ft));
 
     CodeScopeUnit* entryCompilation = getScopeUnit(entry);
     llvm::Function::arg_iterator fargsI = raw->arg_begin();
     for (std::string &arg : entry->__args) {
         VID argid = entry->__vartable[arg];
 
         entryCompilation->__rawVars[argid] = fargsI;
         fargsI->setName(arg);
         ++fargsI;
     }
 
     const std::string blockName =  "entry";
     llvm->builder.CreateRet(entryCompilation->compile(blockName));
 
     llvm->moveToGarbage(ft);
     return raw;
 }
 
-//TEST FunctionUnit::compileInline
 llvm::Value*
 CompilePass::FunctionUnit::compileInline(std::vector<llvm::Value *> &&args, CompilePass::FunctionUnit* outer){
     CodeScopeUnit* entryCompilation = outer->getScopeUnit(function->__entry);
     for(int i=0, size = args.size(); i<size; ++i) {
         entryCompilation->bindArg(args.at(i), string(entryCompilation->scope->__args.at(i)));
     }
 
 
     return entryCompilation->compile();
 }
 
 CompilePass::CodeScopeUnit*
 CompilePass::FunctionUnit::getScopeUnit(CodeScope* scope){
     if (!scopes.count(scope)){
         CodeScopeUnit* unit = new CodeScopeUnit(scope, this, pass);
         scopes.emplace(scope, std::unique_ptr<CodeScopeUnit>(unit));
     }
 
     return scopes.at(scope).get();
 }
 
 CompilePass::CodeScopeUnit*
 CompilePass::FunctionUnit::getEntry(){
 	return getScopeUnit(function->getEntryScope());
 }
 
 CompilePass::CodeScopeUnit*
 CompilePass::FunctionUnit::getScopeUnit(ManagedScpPtr scope){
     return getScopeUnit(&*scope);
 }
 
 CompilePass::FunctionUnit*
 CompilePass::getFunctionUnit(const CompilePass::FunctionQuery& f){
     ManagedFnPtr fkey = man->root->findFunction(f.name);
 
     	//external functions:
     if (!fkey){
     	return nullptr;
     }
 
     if (!functions.count(&*fkey)){
         functions.emplace(&*fkey, std::unique_ptr<FunctionUnit>(new FunctionUnit(fkey, this)));
     }
 
     return functions.at(&*fkey).get();
 }
 
 void
 CompilePass::run(){
     //Find out main function;
-    ClaspLayer::ModelRange model = man->clasp->query(Config::get("function-entry"));
+    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(move(nameMain));
     entry = unitMain->compile();
 }
 
 llvm::Function*
 CompilePass::getEntryFunction(){
 	assert(entry);
 	return entry;
 }
 
 
 //CODESCOPE COMPILATION PHASE
 
 
 //FIND SYMBOL(compilation phase):
     //if (!forceCompile)
     //{
     //    return result;
     //}
 
     //    //search in already compiled vars
     //if (__rawVars.count(vId))
     //{
     //    return result;
     //}
 
     //if (!__declarations.count(vId)) {
     //    //error: symbol is uncompiled scope arg
     //    assert(false);
     //}
 
     //const Expression& e = __declarations.at(vId);
 
     //__rawVars[vId] = process(e, l, name);
 
 
 //FIND FUNCTION
     //llvm::Function*
     //CompilePass::findFunction(const std::string& name){
     //    ManagedFnPtr calleeFunc = man->root->findFunction(name);
     //    assert(calleeFunc.isValid());
 
     //    return  nullptr;
     //}
diff --git a/cpp/src/pass/dfgpass.cpp b/cpp/src/pass/dfgpass.cpp
index 197541f..5520d2f 100644
--- a/cpp/src/pass/dfgpass.cpp
+++ b/cpp/src/pass/dfgpass.cpp
@@ -1,184 +1,187 @@
 #include "dfgpass.h"
 #include "passmanager.h"
 #include "clasplayer.h"
 #include <boost/format.hpp>
-using namespace xreate;
 using namespace std;
 
+namespace xreate{
 DFGPass::DFGPass(PassManager* manager)
         : AbstractPass(manager), clasp(man->clasp)
 {}
 
 SymbolNode
 DFGPass::process(ManagedFnPtr function){
 	SymbolNode symbolRet = AbstractPass::process(function);
 
     if (SymbolPacked* symbolRetPacked = boost::get<SymbolPacked>(&symbolRet)){
 		Expression retExpr(Operator::CALL, {Atom<Identifier_t>(Config::get("clasp.ret.symbol")),
             Atom<Identifier_t>(boost::str(boost::format("(%1%, %2%)")
                                                 %(symbolRetPacked->identifier)
                                                 % (symbolRetPacked->scope)))
 		});
 
 		const std::vector<Tag> tag{{retExpr, TagModifier::NONE}};
 		clasp->cfagraph.addFunctionNodeTags(function->getName(), tag);
 
     }	else if (SymbolTransient* symbT = boost::get<SymbolTransient>(&symbolRet)){
 		std::vector<Tag> tags;
 		tags.reserve(symbT->tags.size());
 
 		const std::string stmntRetTag = Config::get("clasp.ret.tag");
 		std::transform(symbT->tags.begin(), symbT->tags.end(), std::inserter(tags, tags.begin()),
 				[&stmntRetTag](const Expression& e) {
                     Expression tag(Operator::CALL, {Atom<Identifier_t>(string(stmntRetTag)), e});
                     return Tag{e, TagModifier::NONE};
 		});
 
 		clasp->cfagraph.addFunctionNodeTags(function->getName(), tags);
 	}
+
+    return SymbolInvalid();
 }
 
 SymbolNode
 DFGPass::process(const Expression& expression, PassContext context, const std::string& decl)
 {
         // write down adhoc expression tags:
     if (expression.tags.size() && decl.length()) {
         for (pair<std::string, Expression> tag: expression.tags) {
-            SymbolNode nodeThis = clasp->pack(context.scope->findSymbol(decl), decl);
+            SymbolNode nodeThis = clasp->pack(context.scope->findSymbol(decl), context.function->getName() + ":" + decl);
             __context.graph.addTag(nodeThis, Expression(tag.second));
         }
     }
 
     switch(expression.__state) {
-        case Expression::IDENT:
+        case Expression::IDENT: {
             const string& ident = expression.getValueString();
         	SymbolNode nodeFrom = AbstractPass::process(expression, context, decl);
-            SymbolPacked nodeTo = clasp->pack(context.scope->findSymbol(ident));
+            SymbolPacked nodeTo = clasp->pack(context.scope->findSymbol(ident), context.function->getName() + ":" + ident);
 
             __context.graph.addLink(nodeTo, nodeFrom, DFGConnection::ALIAS);
             return nodeTo;
+        }
+
+        default: break;
     }
 
     //special case for NONE value:
     if (expression.isNone()){
         return SymbolTransient{{Atom<Identifier_t>(Config::get("clasp.nonevalue"))}};
     }
 
 
     switch(expression.op) {
         case Operator::CALL: {
             const string &name = expression.getValueString();
 
             std::vector<SymbolNode> operands;
             operands.reserve(expression.getOperands().size());
 
             for (const Expression &op: expression.getOperands()) {
                 operands.push_back(process(op, context));
             }
 
             ManagedFnPtr function = man->root->findFunction(name);
             if (!function) return SymbolInvalid();
 
             	// set calling relations:
             CodeScope *scopeRemote = function->getEntryScope();
-            std::vector<SymbolNode>::iterator op = operands.begin();
-            for (const std::string &arg: scopeRemote->__args) {
-                    const Symbol &nodeRemote = scopeRemote->findSymbol(arg);
-
-                    SymbolPacked* operandPacked = boost::get<SymbolPacked>(&*op);
-                    assert(operandPacked);
-                    __context.graph.addLink(clasp->pack(nodeRemote), *operandPacked, DFGConnection::OPT);
-                ++op;
+            std::vector<SymbolNode>::iterator nodeActual = operands.begin();
+            for (const std::string &identFormal: scopeRemote->__args) {
+                    const Symbol &symbolFormal = scopeRemote->findSymbol(identFormal);
+                    __context.graph.addLink(clasp->pack(symbolFormal, name + ":" + identFormal), *nodeActual, DFGConnection::OPT);
+                ++nodeActual;
             }
 
             	//TODO need SymbolTransient::connection mark in order to represent OPT connection
-            return clasp->pack(Symbol{0, scopeRemote});
+            return clasp->pack(Symbol{0, scopeRemote}, name + ": *retv");
         }
+
+        default: break;
     }
 
-	std::vector<SymbolNode> operands;
+
+
+    SymbolNode result = AbstractPass::process(expression, context, decl);
 
     if (expression.__state != Expression::COMPOUND){
-	    AbstractPass::process(expression, context, decl);
-        return SymbolInvalid();
+        return result;
 	}
 
+    std::vector<SymbolNode> operands;
 	if (__signatures.count(expression.op)) {
 		const Expression &scheme = __signatures.at(expression.op);
 
 		operands.reserve(expression.getOperands().size());
 
         if (expression.op == Operator::CALL || expression.op == Operator::INDEX){
             string caption = expression.getValueString();
             operands.push_back(process(Expression(move(caption)), context, ""));
         }
 
 		for (const Expression &op: expression.getOperands()) {
 			operands.push_back(process(op, context));
 		}
 
         std::vector<SymbolNode>::iterator arg = operands.begin();
 		std::vector<Expression>::const_iterator tag = ++scheme.getOperands().begin();
 
 		while (tag != scheme.getOperands().end()) {
 			if (tag->__state != Expression::INVALID) {
 				__context.graph.addTag(*arg, Expression(*tag));
 			}
 
 			++arg; ++tag;
 		}
 
 		Expression retTag = *scheme.getOperands().begin();
 		if (retTag.__state != Expression::INVALID) {
-			return SymbolTransient{{retTag}};
+            __context.graph.addTag(result, move(retTag));
 		}
 	}
 
-			// adhoc for MAP case, TODO reorganize code in more clear manner
-	if (expression.op == Operator::MAP) {
+    // adhoc for MAP case, TODO reorganize code in more clear manner
+    if (expression.op == Operator::MAP) {
         SymbolNode nodeFrom;
 
-		if (operands.size()) {
-			nodeFrom = operands.at(0);
-		} else {
-			nodeFrom = process(expression.getOperands().at(0), context);
-		}
+        if (operands.size()) {
+            nodeFrom = operands.at(0);
+        } else {
+            nodeFrom = process(expression.getOperands().at(0), context);
+        }
 
-		assert(!decl.empty());
-		SymbolPacked nodeTo = clasp->pack(context.scope->findSymbol(decl));
+        assert(!decl.empty());
+        SymbolPacked nodeTo = clasp->pack(context.scope->findSymbol(decl), context.function->getName() + ":" + decl);
         SymbolPacked* nodeFromPacked = boost::get<SymbolPacked>(&nodeFrom);
         assert(nodeFromPacked);
         __context.graph.addLink(move(nodeTo), *nodeFromPacked, DFGConnection::PROTO);
-	}
-
-	if (__signatures.count(expression.op) || expression.op == Operator::MAP) {
-		for (CodeScope* scope: expression.blocks) {
-			AbstractPass::process(scope, context);
-		}
-
-        return SymbolInvalid();
-	}
+    }
 
-    return SymbolInvalid();
+    return result;
 }
 
 void
 DFGPass::run()
 {
     init();
     return AbstractPass::run();
 }
 
 void
 DFGPass::init()
 {
     for (const Expression& scheme: man->root->__dfadata)
     {
         __signatures.emplace(scheme.op, scheme);
     }
 }
 
 void DFGPass::finish()
 {
     man->clasp->addDFAData(move(__context.graph));
 }
+
+template<>
+SymbolNode defaultValue(){return SymbolInvalid();};
+
+}
diff --git a/cpp/src/pass/environmenttestspass.cpp b/cpp/src/pass/environmenttestspass.cpp
new file mode 100644
index 0000000..bac56b7
--- /dev/null
+++ b/cpp/src/pass/environmenttestspass.cpp
@@ -0,0 +1,30 @@
+/*
+ * environmenttestspass.cpp
+ *
+ *  Created on: Nov 17, 2015
+ *      Author: pgess
+ */
+
+#include <string>
+#include <list>
+
+void
+EnvironmentTestsPass::run(){
+
+		list<string> arftefacts =  solver->query("depends(env())");
+
+			//check artifacts
+		for (artefact: artifacts){
+			Function funcProbe = findProberForArtefact(artefact);
+
+			result = funcProbe->run();
+			results->save(result);
+		}
+
+		for (artefact: artefacts){
+			if (results->getResult(artefact)){
+				Function funcProvider = findProviderForArtefact(artefact);
+				funcProvider->run();
+			}
+		}
+}
diff --git a/cpp/src/pass/environmenttestspass.h b/cpp/src/pass/environmenttestspass.h
new file mode 100644
index 0000000..651acda
--- /dev/null
+++ b/cpp/src/pass/environmenttestspass.h
@@ -0,0 +1,17 @@
+/*
+ * environmenttestspass.h
+ *
+ *  Created on: Nov 17, 2015
+ *      Author: pgess
+ */
+
+#ifndef SRC_PASS_ENVIRONMENTTESTSPASS_H_
+#define SRC_PASS_ENVIRONMENTTESTSPASS_H_
+
+
+
+class EnvironmentTestsPass {
+
+}
+
+#endif /* SRC_PASS_ENVIRONMENTTESTSPASS_H_ */
diff --git a/cpp/src/query/containers.cpp b/cpp/src/query/containers.cpp
index 0881b47..662f41e 100644
--- a/cpp/src/query/containers.cpp
+++ b/cpp/src/query/containers.cpp
@@ -1,161 +1,163 @@
 //
 // Created by pgess on 3/14/15.
 //
 
 #include <clasplayer.h>
 #include "query/containers.h"
 
 using namespace std;
 using namespace xreate::containers;
 using namespace xreate;
 
 
 
 Implementation
 Query::queryImplementation(xreate::Symbol const &s) {
 
     typedef SymbolAttachments attach;
     if (attach::exists<Implementation>(s))
     {
         return attach::get<Implementation>(s);
     }
 
     return  Implementation::create(s);
 }
 
 void
 Query::init(ClaspLayer* clasp)
 {
     if (flagIsDataLoaded) return;
 
     map<Symbol, Symbol> prototypes;
     map<Symbol, string> roots;
 
         //read all proto data
     auto range = clasp->query(Config::get("containers.id.prototypes"));
     if (range)
     for(ClaspLayer::ModelIterator atom = range->first; atom != range->second; ++atom) {
         auto data =  ClaspLayer::parse<SymbolPacked, SymbolPacked>(atom->second);
         Symbol root = clasp->unpack(get<0> (data));
         Symbol prototype = clasp->unpack(get<1> (data));
 
         prototypes[root] = prototype;
     }
 
         // fill implementation data for a data sources:
     range = clasp->query(Config::get("containers.id.implementations"));
     if (range)
     for(ClaspLayer::ModelIterator atom = range->first; atom != range->second; ++atom)
     {
         auto data = ClaspLayer::parse<SymbolPacked, string>(atom->second);
 
         Symbol var  = clasp->unpack(get<0>(data));
         string implSerialized  = get<1>(data);
 
             //data source, has no prototypes:
         if (!prototypes.count(var))
         {
             Implementation impl = Implementation::create(var);
             SymbolAttachments::put<Implementation>(var, move(impl));
             continue;
         }
 
         roots.emplace(move(var), move(implSerialized));
     }
 
         //fill implementation data for a cluster roots
     for (const pair<Symbol, string> &  root: roots)
     {
         Symbol prototype = prototypes[root.first];
 
         while (prototypes.count(prototype))        {
             prototype = prototypes.at(prototype);
         }
 
         SymbolAttachments::put<Implementation>(root.first, Implementation(SymbolAttachments::get<Implementation>(prototype)));
     }
 
     // read cluster data and fill implementation data for cluster members
     range = clasp->query(Config::get("containers.id.clusters"));
     if (range)
     for(ClaspLayer::ModelIterator atom = range->first; atom != range->second; ++atom)
     {
         auto info = ClaspLayer::parse<SymbolPacked, SymbolPacked>(atom->second);
 
         Symbol root =  clasp->unpack(get<0>(info));
         Symbol child =  clasp->unpack(get<1>(info));
 
         if (!(child == root)) {
             Implementation rootImpl = SymbolAttachments::get<Implementation>(root);
             SymbolAttachments::put<Implementation>(child, move(rootImpl));
         }
     }
 
     flagIsDataLoaded = true;
 }
 
 //static ImplementationData* create(Symbol var, std::string implSerialized, const ImplementationData* implPrototype);
 
 Implementation
 Implementation::create(const Symbol &var)
 {
     Expression varDecl = CodeScope::findDeclaration(var);
     switch (varDecl.op)
     {
         case Operator::LIST_RANGE: {
             ImplementationRec<ON_THE_FLY> rec{var};
             return {ON_THE_FLY, rec};
         }
 
         case Operator::LIST: {
             return {SOLID, ImplementationRec<SOLID> {varDecl.getOperands().size()}};
         }
+
+    default: break;
     };
 
     ImplementationLinkedList ill(var);
     if (ill){
     	return ill.getImplementationData();
     }
 
     assert(false && "Unable to determine proper implementation for the symbol");
 }
 
 Implementation
 Implementation::create(const Symbol& var, const std::string& implSerialized)
 {
     Expression varDecl = CodeScope::findDeclaration(var);
     if (implSerialized == Config::get("containers.impl.solid"))
     {
         return {SOLID, ImplementationRec<SOLID>{varDecl.operands.size()}};
 
     } else if (implSerialized == Config::get("containers.impl.onthefly")) {
         return {ON_THE_FLY, ImplementationRec<ON_THE_FLY>{var}};
     }
 
     assert(false && "unable to determine proper implementation for the symbol");
 }
 
 
 ImplementationLinkedList::ImplementationLinkedList(const Symbol& source)
         :    flagIsValid(false), s(source){
 
 	const Expression& sourceExpr = CodeScope::findDeclaration(source);
 
 	if (sourceExpr.tags.count(Config::get("containers.id.linkedlist"))){
         flagIsValid = true;
 
         Expression tagLinkedlist = sourceExpr.tags.at(Config::get("containers.id.linkedlist"));
 		assert(tagLinkedlist.operands.size() == 2);
 		fieldPointer = tagLinkedlist.operands.at(0).getValueString();
 		terminator = tagLinkedlist.operands.at(1);
 	}
 }
 
 ImplementationLinkedList:: operator bool () const{
     return flagIsValid;
 }
 
 Implementation
 ImplementationLinkedList::getImplementationData() const {
 	return {ON_THE_FLY, ImplementationRec<ON_THE_FLY>{s}};
 }
diff --git a/cpp/tests/CFGtests.cpp b/cpp/tests/CFGtests.cpp
index 44e92ef..cbda26a 100644
--- a/cpp/tests/CFGtests.cpp
+++ b/cpp/tests/CFGtests.cpp
@@ -1,62 +1,62 @@
 /*
  * testsCFG.cpp
  *
  *  Created on: Jul 17, 2015
  *      Author: pgess
  */
 
 #include "passmanager.h"
 #include "pass/dfgpass.h"
 #include "gtest/gtest.h"
 
 using namespace xreate;
 using namespace std;
 
 TEST(CFG, testFunctionAnnotationsClasp){
 	string&& program =
 			"f2 = function()::int; annotationF2 {\n"
 			"    0\n"
 			"}\n"
 			"\n"
 			"f1 = function():: int; entry; annotationF1 {\n"
 			"    f2() + 10\n"
 			"}";
 
 
 	PassManager* man = PassManager::prepareForCode(move(program));
 	man->runWithoutCompilation();
 
-	ClaspLayer::ModelRange answer = man->clasp->query("annotationF1");
+	ClaspLayer::ModelFragment answer = man->clasp->query("annotationF1");
 	int countNoneValue = 0;
 	if (answer)
 		countNoneValue = std::distance(answer->first, answer->second);
 	EXPECT_EQ(1, countNoneValue);
 
 	answer = man->clasp->query("annotationF2");
 	countNoneValue = 0;
 	if (answer)
 		countNoneValue = std::distance(answer->first, answer->second);
-	EXPECT_EQ(1, countNoneValue);
+    EXPECT_EQ(1, countNoneValue);
 }
 
 TEST(CFG, testLoopContextExists){
 	PassManager* man = PassManager::prepareForCode (
 		"interface(cfa){\n"
 		"    operator fold:: annotation1.\n"
 		"}\n"
 		"\n"
 		"main = function() :: int; entry {\n"
 		"    x = [1..10]:: [int].\n"
 		"    sum = loop fold (x->el:: int, 0->sum:: int):: [int] {\n"
 		"        el + sum + f1()\n"
 		"    }.  \n"
 		"    sum\n"
 		"}"
 		"f1 = function()::int {\n"
 		"	x = 0:: int.		 "
 		"    x\n"
 		"}"
     );
 
 	man->runWithoutCompilation();
 }
diff --git a/cpp/tests/DFGtests.cpp b/cpp/tests/DFGtests.cpp
index fd82f58..7371367 100644
--- a/cpp/tests/DFGtests.cpp
+++ b/cpp/tests/DFGtests.cpp
@@ -1,42 +1,42 @@
 /*
  * DFGtests.cpp
  *
  *  Created on: Jul 23, 2015
  *      Author: pgess
  */
 #include "passmanager.h"
 #include "pass/dfgpass.h"
 
 #include "gtest/gtest.h"
 using namespace xreate;
 using namespace std;
 
 TEST(DFG, testFunctionRetSymbolExists){
 	PassManager* man = PassManager::prepareForCode
 			("test = function():: int; entry  {\n"
 			"  data = [1..5]::[int].\n"
 			"  \n"
 			"  result = loop fold(data->i::int, 0->sum::int)::int{\n"
 			"    if (i==3)::int {valNull = null. valNull} else {i+sum}\n"
 			"  }.\n"
 			"  \n"
 			"  result\n"
 			"}");
 
 	man->runWithoutCompilation();
-	ClaspLayer::ModelRange answer = man->clasp->query(Config::get("clasp.ret.symbol"));
+	ClaspLayer::ModelFragment answer = man->clasp->query(Config::get("clasp.ret.symbol"));
 
 	if (answer)
 		EXPECT_EQ(1, std::distance(answer->first, answer->second));
 
 	for (auto functionIt = answer->first; functionIt != answer->second; ++functionIt){
 		auto ret = ClaspLayer::parse<string, Gringo::Value>(functionIt->second);
 
 		ASSERT_EQ("test", std::get<0>(ret));
 
 		SymbolPacked symbolRet = std::get<0>(ClaspLayer::parse<SymbolPacked>(std::get<1>(ret)));
 		ASSERT_EQ(3, symbolRet.identifier);
 		ASSERT_EQ(0, symbolRet.scope);
 	}
 }
 
diff --git a/cpp/tests/ast.cpp b/cpp/tests/ast.cpp
index 2929080..7c4de20 100644
--- a/cpp/tests/ast.cpp
+++ b/cpp/tests/ast.cpp
@@ -1,41 +1,49 @@
 /*
  * ast.cpp
  *
  *  Created on: Jun 11, 2015
  *      Author: pgess
  */
 
 #include "gtest/gtest.h"
 #include "passmanager.h"
 #include "Parser.h"
 
 using namespace std;
 using namespace xreate;
 
 TEST(AST, Containers1){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	Scanner scanner(input);
     Parser parser(&scanner);
     parser.Parse();
 
     const AST& ast = parser.root;
 
 	fclose(input);
 }
 
-TEST(AST, CFAData) {
+TEST(AST, InterfacesDataCFA) {
 	PassManager* man = PassManager::prepareForCode
 				("interface(cfa){\n"
 				"    operator map :: annotation1.\n"
 				"}");
 
 	auto answer = man->root->__interfacesData.equal_range(CFA);
 	EXPECT_EQ(1, std::distance(answer.first, answer.second));
 
 	Expression&& scheme = move(answer.first->second);
 
 	EXPECT_EQ(Operator::MAP, scheme.op);
 	EXPECT_EQ("annotation1", scheme.getOperands().at(0).getValueString());
 }
 
+TEST(AST, DISABLED_InterfacesDataDFA){
+
+}
+
+TEST(AST, DISABLED_InterfacesDataExtern){
+
+}
+
 
diff --git a/cpp/tests/compilation.cpp b/cpp/tests/compilation.cpp
new file mode 100644
index 0000000..c305e3e
--- /dev/null
+++ b/cpp/tests/compilation.cpp
@@ -0,0 +1,5 @@
+#include "gtest/gtest.h"
+
+//TEST FunctionUnit::compileInline
+TEST(Compilation, DISABLED_functionInline1){
+}
diff --git a/cpp/tests/containers.cpp b/cpp/tests/containers.cpp
index 4c149bc..611ccfe 100644
--- a/cpp/tests/containers.cpp
+++ b/cpp/tests/containers.cpp
@@ -1,57 +1,54 @@
 /*
  * containers.cpp
  *
  *  Created on: Jun 9, 2015
  *      Author: pgess
  */
 #include "gtest/gtest.h"
 #include "passmanager.h"
 #include "Parser.h"
 #include "query/containers.h"
 
 using namespace std;
 using namespace xreate;
 using namespace containers;
 
-TEST(Containers, DISABLED_DFAData1){
-}
-
 TEST(Containers, ContanierLinkedList1){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
 	Parser parser(&scanner);
 	parser.Parse();
 
 	AST& ast = parser.root;
 	CodeScope* body = ast.findFunction("test")->getEntryScope();
 	Symbol symb_chilrenRaw = body->findSymbol("childrenRaw");
 
 	containers::ImplementationLinkedList iLL(symb_chilrenRaw);
 
 	ASSERT_EQ(true, static_cast<bool>(iLL));
 	ASSERT_EQ("next", iLL.fieldPointer);
 
 	Implementation impl = Implementation::create(symb_chilrenRaw);
 	ASSERT_NO_FATAL_FAILURE(impl.extract<ON_THE_FLY>());
 
 	ImplementationRec<ON_THE_FLY> recOnthefly = impl.extract<ON_THE_FLY>();
 	ASSERT_EQ(symb_chilrenRaw, recOnthefly.source);
 }
 
 TEST(Containers, Implementation_LinkedListFull){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
     std::unique_ptr<PassManager> program(PassManager::prepareForCode(scanner));
 	void* mainPtr = program->run();
 	int (*main)() = (int (*)())(intptr_t)mainPtr;
 
 	int answer = main();
 	ASSERT_EQ(16, answer);
 
 	fclose(input);
 }
 
diff --git a/cpp/tests/diagnostic-messages.cpp b/cpp/tests/diagnostic-messages.cpp
new file mode 100644
index 0000000..b46cdf0
--- /dev/null
+++ b/cpp/tests/diagnostic-messages.cpp
@@ -0,0 +1,28 @@
+/*
+ * diagnostic-messages.cpp
+ *
+ *  Created on: Oct 27, 2015
+ *      Author: pgess
+ */
+
+#include "gtest/gtest.h"
+
+using namespace std;
+
+TEST(Diagnostic_DFA, DISABLED_recursion1){
+
+		//Error while processing recursion, Should be some diagnostic complaints
+	std::string code = \
+			"test1 = function()::[int] {\n"
+			"	varRecursion = loop map(varRecursion->el:: int)::[int]{\n"
+			"		el\n"
+			"	}.\n"
+			"	\n"
+			"	varRecursion\n"
+			"}";
+
+	PassManager* man = PassManager::prepareForCode(code);
+	DFGPass* pass = new DFGPass(man);
+	pass->run();
+	pass->finish();
+}
diff --git a/cpp/tests/externc.cpp b/cpp/tests/externc.cpp
index ae6287a..ba12e3c 100644
--- a/cpp/tests/externc.cpp
+++ b/cpp/tests/externc.cpp
@@ -1,104 +1,104 @@
 #include "gtest/gtest.h"
 #include "passmanager.h"
 #include "Scanner.h"
 #include "Parser.h"
 #include <iostream>
 #include <llvm/Support/DynamicLibrary.h>
 
 using namespace std;
 
 TEST(InterfaceExternC, testAST){
 	std::string code = "											\
 			interface(extern-c){									\
 			  xml2 = library:: pkgconfig(\"libxml-2.0\").				\
 			  	  	  	  	  	  	  	  	  	  	  	  	  	  	\
 			  include {												\
 			    xml2 = [\"libxml/tree.h\"]							\
 			  }.													\
 			}   													\
 			";
 
     Scanner scanner(reinterpret_cast<const unsigned char*>(code.c_str()), code.size());
     Parser parser(&scanner);
     parser.Parse();
 
     ASSERT_EQ(1, parser.root.__externdata.size());
 
     for (const ExternEntry& lib: parser.root.__externdata){
     	ASSERT_EQ("libxml-2.0", lib.package);
     	ASSERT_EQ(1, lib.headers.size());
     	ASSERT_EQ("libxml/tree.h", lib.headers.at(0));
     }
 }
 
 TEST(InterfaceExternC, testfetchPackageHeaders){
 	ExternEntry entry{"libxml-2.0", {}};
 
 	vector<string> args = ExternLayer::fetchPackageFlags(entry);
 	ASSERT_EQ(1, args.size());
 	ASSERT_EQ("-I/usr/include/libxml2", args.at(0));
 }
 
 TEST(InterfaceExternC, testfetchPackageLibs){
 	ExternEntry entry{"libxml-2.0", {}};
 
 	vector<string> args = ExternLayer::fetchPackageLibs(entry);
 	ASSERT_EQ(1, args.size());
-	ASSERT_EQ("-lxml2", args.at(0));
+    ASSERT_EQ("xml2", args.at(0));
 }
 
 TEST(InterfaceExternC, testLoadLib){
 	std::string msgErr;
 	if (!llvm::sys::DynamicLibrary::LoadLibraryPermanently("-lpcre -lxml2", &msgErr)){
 		cout << msgErr;
 		ASSERT_EQ("", msgErr);
 	}
 
 	ASSERT_TRUE(true);
 }
 
 TEST(InterfaceExternC, testBSD1){
 	std::string code = "											\n\
 				interface(extern-c){									\n\
 				  libbsd = library:: pkgconfig(\"libbsd\").				\n\
 				  	  	  	  	  	  	  	  	  	  	  	  	  	  	\n\
 				  include {												\n\
 				    libbsd = [\"bsd/stdlib.h\"]							\n\
 				  }.													\n\
 				}\n"
 				"main= function():: int; entry{arc4random() }";
 
 	std::unique_ptr<PassManager> program(PassManager::prepareForCode(move(code)));
 
 	void* entryPtr = program->run();
 	int (*entry)() = (int (*)())(intptr_t)entryPtr;
 
 	int answer = 24;
 	answer = entry();
 	cout << answer;
 	ASSERT_NE(24, answer);
 }
 
 TEST(InterfaceExternC, testStructFields1){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
 	Parser parser(&scanner);
 	parser.Parse();
 
 	AST& ast = parser.root;
 	CodeScope* body = ast.findFunction("test")->getEntryScope();
 
 	Symbol symbTree = body->findSymbol("tree");
 
     const TypeAnnotation& tTree = CodeScope::findDefinition(symbTree);
     const ExpandedType& t2Tree = ast.expandType(tTree);
     LLVMLayer llvm(&ast);
     TypeUtils utils(&llvm);
 
     std::vector<std::string>fields = utils.getStructFields(t2Tree);
 
     auto field = std::find(fields.begin(), fields.end(), "children");
     ASSERT_TRUE(field != fields.end());
 }
diff --git a/cpp/tests/pointers.cpp b/cpp/tests/pointers.cpp
new file mode 100644
index 0000000..e2e05a9
--- /dev/null
+++ b/cpp/tests/pointers.cpp
@@ -0,0 +1,9 @@
+#include "gtest/gtest.h"
+
+TEST(Pointers, DISABLED_validptr1){
+
+}
+
+TEST(Pointers, DISABLED_localscopeptr1){
+
+}
diff --git a/cpp/tests/safety.cpp b/cpp/tests/safety.cpp
index 2af6879..e69de29 100644
--- a/cpp/tests/safety.cpp
+++ b/cpp/tests/safety.cpp
@@ -1,9 +0,0 @@
-#include "gtest/gtest.h"
-
-/**
- * 	Safety checks:
- * 		(*) valid ptr (not null)
- */
-TEST(Safety, validptr1){
-
-}
diff --git a/cpp/tests/skipdetection.cpp b/cpp/tests/skipdetection.cpp
index 5ccb14b..c1ba1a2 100644
--- a/cpp/tests/skipdetection.cpp
+++ b/cpp/tests/skipdetection.cpp
@@ -1,32 +1,32 @@
 /*
  * skipdetection.cpp
  *
  *  Created on: Jul 10, 2015
  *      Author: pgess
  */
 
 #include "passmanager.h"
 #include "clasplayer.h"
 #include "gtest/gtest.h"
 
 using namespace xreate;
 using namespace std;
 TEST(SkipDetection, testNoneValueTagExists){
 	PassManager* man = PassManager::prepareForCode
 			("test = function():: int; entry  {\n"
 			"  data = [1..5]::[int].\n"
 			"  \n"
 			"  result = loop fold(data->i::int, 0->sum::int)::int{\n"
 			"    if (i==3)::int {valNull = null. valNull} else {i+sum}\n"
 			"  }.\n"
 			"  \n"
 			"  result\n"
 			"}");
 
 	man->runWithoutCompilation();
-	ClaspLayer::ModelRange answer = man->clasp->query(Config::get("clasp.nonevalue"));
+	ClaspLayer::ModelFragment answer = man->clasp->query(Config::get("clasp.nonevalue"));
 	int countNoneValue = 0;
 	if (answer)
 		countNoneValue = std::distance(answer->first, answer->second);
 	EXPECT_EQ(1, countNoneValue);
 }
diff --git a/cpp/tests/testBasic.cpp b/cpp/tests/testBasic.cpp
index 9cb9a5c..1f1acb5 100644
--- a/cpp/tests/testBasic.cpp
+++ b/cpp/tests/testBasic.cpp
@@ -1,26 +1,26 @@
 
 #include "gtest/gtest.h"
 #include "passmanager.h"
 #include "Scanner.h"
 #include "Parser.h"
 #include <iostream>
 #include <llvm/Support/DynamicLibrary.h>
 
 using namespace std;
 using namespace xreate;
 
-TEST(EntryFunction, test1){
+TEST(Basic, functionEntry1){
     std::unique_ptr<PassManager> program(PassManager::prepareForCode(
         "func1 = function(a:: int):: int {a+8} \
          func2 = function()::int; entry {12 + func1(4)}      \
         "));
 
     void* entryPtr = program->run();
     int (*entry)() = (int (*)())(intptr_t)entryPtr;
 
     int answer = entry();
     ASSERT_EQ(24, answer);
 }
 
 
 
diff --git a/cpp/tests/testClangAPI.cpp b/cpp/tests/testClangAPI.cpp
index 15bcd61..0005ad2 100644
--- a/cpp/tests/testClangAPI.cpp
+++ b/cpp/tests/testClangAPI.cpp
@@ -1,190 +1,190 @@
 //
 // Created by pgess on 4/16/15.
 //
 
 #include "gtest/gtest.h"
 
 #include <llvm/IR/DerivedTypes.h>
 #include "clang/Driver/Options.h"
 #include "clang/AST/AST.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTConsumer.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/Frontend/ASTConsumers.h"
 #include "clang/Frontend/FrontendActions.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
 #include "clang/CodeGen/CodeGenAction.h"
 #include "/opt/llvm-toolchain-3.6-3.6/clang/lib/CodeGen/CodeGenTypes.h"
 #include "/opt/llvm-toolchain-3.6-3.6/clang/lib/CodeGen/CodeGenModule.h"
 #include "clang/CodeGen/CodeGenABITypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include "clang/Basic/TargetInfo.h"
 #include <boost/format.hpp>
 
 
 
 using namespace std;
 using namespace clang;
 using namespace clang::driver;
 using namespace clang::tooling;
 using namespace clang::ast_matchers;
 using namespace llvm;
 
 /*
 class PrintFunctionsConsumer : public ASTConsumer {
 public:
     bool HandleTopLevelDecl(DeclGroupRef DG) override {
         for (DeclGroupRef::iterator i = DG.begin(), e = DG.end(); i != e; ++i) {
             const Decl *D = *i;
             if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
                 llvm::errs() << "top-level-decl: \"" << ND->getNameAsString() << "\"\n";
         }
 
         return true;
     }
 };
 
 class PFAction : public ASTFrontendAction {
 public:
     virtual std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI, StringRef file) {
         return llvm::make_unique<PrintFunctionsConsumer>();
     }
 };
 */
 
 class PrinterType : public MatchFinder::MatchCallback {
 public :
     virtual void run(const MatchFinder::MatchResult &Result) {
         ASTContext* C = Result.Context;
         llvm::Module* M = new llvm::Module("module1", llvm::getGlobalContext());
         if (const TypedefDecl* decl = Result.Nodes.getNodeAs<clang::TypedefDecl>("typename")) {
             QualType Ty = decl->getUnderlyingType();
 
             llvm::errs() << "<" << Ty.getAsString()  << ">" ;
 
             CodeGenOptions *CGO = new CodeGenOptions;
 
             const llvm::DataLayout& TD  = llvm::DataLayout(C->getTargetInfo().getTargetDescription());
             CodeGen::CodeGenModule *CGM = new CodeGen::CodeGenModule(*C, *CGO, *M, TD, C->getDiagnostics());
 
             llvm::Type *rawTy =  CGM->getTypes().ConvertType(Ty);
 
             rawTy->dump();
             results.push_back(rawTy);
         }
     }
 
     std::vector<llvm::Type*> results;
 };
 
 class PrinterFunction:  public MatchFinder::MatchCallback {
 public :
 	virtual void run(const MatchFinder::MatchResult &Result) {
 		if (const FunctionDecl* decl = Result.Nodes.getNodeAs<clang::FunctionDecl>("function")) {
 			QualType Ty = decl->getType();
 
 			llvm::errs() << "<" << Ty.getAsString()  << ">" ;
 	        ASTContext* C = Result.Context;
 	        llvm::Module* M = new llvm::Module("module1", llvm::getGlobalContext());
 			CodeGenOptions *CGO = new CodeGenOptions;
 
 			const llvm::DataLayout& TD  = llvm::DataLayout(C->getTargetInfo().getTargetDescription());
 			CodeGen::CodeGenModule *CGM = new CodeGen::CodeGenModule(*C, *CGO, *M, TD, C->getDiagnostics());
 
 			llvm::Type *rawTy =  CGM->getTypes().ConvertType(Ty);
 
 			//const clang::FunctionType* Ty = decl->getType()->getAs<clang::FunctionType>();
 			llvm::FunctionType* rawFuncTy = llvm::dyn_cast<llvm::FunctionType>(rawTy);
 			rawFuncTy->dump();
 			results.push_back(rawFuncTy);
 
 			/*
 			llvm::Function* fDeclaration = llvm::Function::Create(rawFuncTy, llvm::GlobalValue::ExternalLinkage, "xxxx", M);
 			fDeclaration->dump();
 			*/
 		}
 	}
 
 	std::vector<llvm::Type*> results;
 };
 
 //DEBT fix dependency on clasp/gcc version
 vector<string> argv = {
  "-I/usr/include/libxml2"
         ,"-I/usr/local/include"
  ,"-I/usr/lib/llvm-3.6/lib/clang/3.6.0/include"
  ,"-I/usr/include"
 };
 
 TEST(ClangAPI, testExternalType)
 {
 
     //,, "-I/usr/include/linux"
 //    "-cc1", "-emit-pch", "-disable-free", "-disable-llvm-verifier",  "-mrelocation-model", "static",
 //            "-mthread-model", "posix", "-mdisable-fp-elim", "-fmath-errno", "-masm-verbose",
 //            "-mconstructor-aliases", "-munwind-tables", "-fuse-init-array", "-target-cpu", "x86-64", "-target-linker-version", "2.25",
     //"-dwarf-column-info", "-resource-dir", "/usr/lib/llvm-3.7/bin/../lib/clang/3.7.0",
     //"clang", "--",
 
 
     /*
     int argc= argv.size();
 
     llvm::cl::OptionCategory cat("aaaa");
     LLVMInitializeNativeTarget();
     CommonOptionsParser op(argc, &*(argv.begin()), cat);
     ClangTool tool(op.getCompilations(), op.getSourcePathList());
      */
 
     auto matcherType =
             typedefDecl(hasName("xmlNodePtr")).bind("typename");
 
     MatchFinder finder;
     PrinterType printer;
     finder.addMatcher(matcherType, &printer);
 
     std::string code = (boost::format("#include \"%1%\"") % ("libxml/tree.h")).str();
     //runToolOnCodeWithArgs(newFrontendActionFactory(&finder).get()->create(), code, argv);
 
     std::unique_ptr<ASTUnit> ast = buildASTFromCodeWithArgs(code, argv);
     ASTContext & context = ast->getASTContext();
     finder.matchAST(context);
 
-    string signatureExpected = "%struct._xmlNode.0*";
+    string signatureExpected = "%struct._xmlNode*";
     ASSERT_EQ(1, printer.results.size());
 
     llvm::Type* tyActual = printer.results.at(0);
     string strActual;
     llvm::raw_string_ostream ss(strActual);
     tyActual->print(ss);
     ASSERT_EQ(signatureExpected, ss.str());
 
     //int x = tool.run(newFrontendActionFactory(&finder).get());
 }
 
 TEST(ClangAPI, testExternalFunction){
 	auto matcherType = functionDecl(hasName("arc4random")).bind("function");
 
 	MatchFinder finder;
 	PrinterFunction printer;
 	finder.addMatcher(matcherType, &printer);
 
     std::string code = (boost::format("#include \"%1%\"") % ("bsd/stdlib.h")).str();
 	std::unique_ptr<ASTUnit> ast = buildASTFromCodeWithArgs(code, argv);
 	ASTContext & context = ast->getASTContext();
 	finder.matchAST(context);
 
     string signatureExpected = "i32 ()";
     ASSERT_EQ(1, printer.results.size());
 
     llvm::Type* tyActual = printer.results.at(0);
     string strActual;
     llvm::raw_string_ostream ss(strActual);
     tyActual->print(ss);
     ASSERT_EQ(signatureExpected, ss.str());
 }
diff --git a/cpp/tests/testLibXml2.cpp b/cpp/tests/testLibXml2.cpp
index ada2404..a095373 100644
--- a/cpp/tests/testLibXml2.cpp
+++ b/cpp/tests/testLibXml2.cpp
@@ -1,37 +1,36 @@
 //
 // Created by pgess on 3/28/15.
 //
 #include <libxml/xmlmemory.h>
 #include <libxml/parser.h>
 #include <gtest/gtest.h>
 
 using namespace std;
 
 TEST(libxml2, ReadXML)
 {
-	char* docname = "project/documentation.fodt"	;
+    char* docname = "project/documentation.fodt";
     xmlDocPtr doc;
     xmlNodePtr cur;
     doc = xmlParseFile(docname);
     if (doc == NULL ) {
         fprintf(stderr,"Document not parsed successfully. \n");
         return;
     }
     cur = xmlDocGetRootElement(doc);
     if (cur == NULL) {
         fprintf(stderr,"empty document\n");
         xmlFreeDoc(doc);
         return;
     }
 
     cur = cur->xmlChildrenNode;
     int count =0;
     while (cur != NULL) {
         printf("child: %s\n", cur->name);
-
         cur = cur->next;
         count ++;
     }
 
     ASSERT_EQ(17, count);
 }
diff --git a/cpp/tests/tests.cpp b/cpp/tests/tests.cpp
index d0e8410..66078a2 100644
--- a/cpp/tests/tests.cpp
+++ b/cpp/tests/tests.cpp
@@ -1,135 +1,136 @@
 #include "utils.h"
 #include <gtest/gtest.h>
 
 using namespace std;
 using namespace xreate;
 
 int main(int argc, char **argv) {
     testing::GTEST_FLAG(color) = "yes";
 
     string testsTemplate = Config::get("tests.template");
     string testsFilter = Config::get(string("tests.templates.") + testsTemplate);
     testing::GTEST_FLAG(filter) = testsFilter;
     testing::InitGoogleTest(&argc, argv);
     return RUN_ALL_TESTS();
 }
 
+//TODO adopt useful tests
 
 //void testParser_1()
 //{
 //    shared_ptr<Scanner> scanner(new Scanner(L"scripts/input.xreate"));
 //    shared_ptr<Parser> parser(new Parser(scanner.get()));
 //    parser->Parse();
 //    flush(cout);
 
 //    AST& root =  parser->root;
 //    LLVMLayer l(&root);
 
 //    root.compile(l);
 //    root.run(l);
 //}
 
 //void testClasp2()
 //{
 //    shared_ptr<Scanner> scanner(new Scanner(L"scripts/input.xreate"));
 //    shared_ptr<Parser> parser(new Parser(scanner.get()));
 //    parser->Parse();
 //    flush(cout);
 
 //    if (parser->errors->count)
 //    {
 //        cout << "Found " << parser->errors->count << " errors. Stop" << endl;
 //        exit(1);
 //    }
 
 //    AST& root =  parser->root;
 //    ClaspLayer clasp;
 
 //        /*
 //    FunctionTagsPass(root).run(clasp);
 //    RulesPass(root).run(clasp);
 
 //    CFGPass(&clasp).run();
 
 //    clasp.1
 //    run();
 //        */
 //}
 
 //void testUnsafeCode1()
 //{
 //    shared_ptr<Scanner> scanner(new Scanner(L"scripts/cases/bugs-code.xreate"));
 //    shared_ptr<Parser> parser(new Parser(scanner.get()));
 //    parser->Parse();
 //    flush(cout);
 
 //    if (parser->errors->count)
 //    {
 //        cout << "Found " << parser->errors->count << " errors. Stop" << endl;
 //        exit(1);
 //    }
 
 //    AST& root =  parser->root;
 //    ClaspLayer clasp;
 
 //        /*
 //    FunctionTagsPass(root).run(clasp);
 //    RulesPass(root).run(clasp);
 
 //    CFGPass(&clasp).run();
 //    //clasp.addRule(":- call(X, Y), tag(Y, unsafe), not tag(X, unsafe), function(X), function(Y).");
 
 //    clasp.run();
 //        */
 //}
 
 //void test_DFG_1()
 //{
 //    shared_ptr<Scanner> scanner(new Scanner(L"scripts/input.xreate"));
 //    shared_ptr<Parser> parser(new Parser(scanner.get()));
 //    parser->Parse();
 //    flush(cout);
 
 //    if (parser->errors->count)
 //    {
 //        cout << "Found " << parser->errors->count << " errors. Stop" << endl;
 //        exit(1);
 //    }
 
 //    PassManager m;
 //    m.clasp = new ClaspLayer();
 
 //    m.llvm = new LLVMLayer(&parser->root);
 //    m.root = & parser->root;
 //    m.clasp->ast = m.root;
 
 //    m.registerPass(new DFAPass(&m));
 //    m.run();
 
 //    m.clasp->run();
 //    m.root->compile(*m.llvm);
 //    m.root->run(*m.llvm);
 //}
 
 //void test_Xml_1()
 //{
 //    shared_ptr<Scanner> scanner(new Scanner(L"scripts/input.xreate"));
 //    shared_ptr<Parser> parser(new Parser(scanner.get()));
 //    parser->Parse();
 //    flush(cout);
 
 //    if (parser->errors->count)
 //    {
 //        cout << "Found " << parser->errors->count << " errors. Stop" << endl;
 //        exit(1);
 //    }
 
 //    PassManager m;
 //    m.root = & parser->root;
 //    m.clasp = new ClaspLayer();
 //    m.clasp->ast = m.root;
 //    m.llvm = new LLVMLayer(&parser->root);
 
 //    m.registerPass(new DFAPass(&m));
 //    m.run();
 //}
diff --git a/cpp/tests/types.cpp b/cpp/tests/types.cpp
index 1f63042..0967945 100644
--- a/cpp/tests/types.cpp
+++ b/cpp/tests/types.cpp
@@ -1,129 +1,130 @@
 /*
  * types.cpp
  *
  *  Created on: Jun 4, 2015
  *      Author: pgess
  */
 
 #include "gtest/gtest.h"
 #include "passmanager.h"
 #include "llvmlayer.h"
 #include "Parser.h"
 
 using namespace std;
 using namespace xreate;
 
 TEST(Types, DependantTypes1) {
 	string&& code = "XmlNode = type alias {\n"
 			"        tag:: string,\n"
 			"       /* attrs:: [string],*/\n"
 			"        content:: string\n"
 			"}.\n";
 
 	std::unique_ptr<PassManager> program(PassManager::prepareForCode(move(code)));
 	ExpandedType typeXmlNode = program->root->findType("XmlNode");
 
 	ASSERT_EQ(TypeOperator::STRUCT, typeXmlNode->__operator);
 	ASSERT_EQ(2, typeXmlNode->__operands.size());
 	ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(0).__value);
 	ASSERT_EQ(TypePrimitive::String, typeXmlNode->__operands.at(1).__value);
 }
 
 TEST(Types, DependantTypes2) {
 	string&& code = "XmlNode = type alias {\n"
 			"        tag:: string,\n"
 			"       /* attrs:: [string],*/\n"
 			"        content:: string\n"
 			"}.\n"
 			""
 			"Template = type Template(Leaf) [Leaf, [Leaf[content]]]."
 			"Concrete = type alias Template(XmlNode).";
 
 	std::unique_ptr<PassManager> program(PassManager::prepareForCode(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
 
 	ASSERT_EQ(TypeOperator::TUPLE, typeConcrete->__operator);
 	ASSERT_EQ(2, typeConcrete->__operands.size());
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operands.at(0).__operator);
 
 	ASSERT_EQ(TypeOperator::ARRAY, typeConcrete->__operands.at(1).__operator);
 	ASSERT_EQ(TypePrimitive::String, typeConcrete->__operands.at(1).__operands.at(0).__value);
 }
 
 TEST(Types, TreeType1) {
 	string&& code = "XmlNode = type alias {\n"
 			"        tag:: string,\n"
 			"       /* attrs:: [string],*/\n"
 			"        content:: string\n"
 			"}.\n"
 			""
 			"Tree = type Tree(Leaf) [Leaf, [Tree(Leaf)]]."
 			"Concrete = type alias Tree(XmlNode).";
 
 	std::unique_ptr<PassManager> program(PassManager::prepareForCode(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
 	ASSERT_EQ(TypeOperator::TUPLE, typeConcrete->__operator);
 	ASSERT_EQ(2, typeConcrete->__operands.size());
 	ASSERT_EQ(TypeOperator::STRUCT, typeConcrete->__operands.at(0).__operator);
 
 	ASSERT_EQ(TypeOperator::ARRAY, typeConcrete->__operands.at(1).__operator);
 
 	auto typeLink = typeConcrete->__operands.at(1).__operands.at(0);
 	ASSERT_EQ(TypeOperator::LINK, typeLink.__operator);
 	ASSERT_EQ(typeConcrete->conjuctionId,typeLink.conjuctionId);
 }
 
 TEST(Types, TreeType1LLvm){
 	string&& code = "XmlNode = type alias {\n"
 			"        tag:: string,\n"
 			"       /* attrs:: [string],*/\n"
 			"        content:: string\n"
 			"}.\n"
 			""
 			"Tree = type Tree(Leaf) [Leaf, [Tree(Leaf)]]."
 			"Concrete = type alias Tree(XmlNode).";
 
 	std::unique_ptr<PassManager> program(PassManager::prepareForCode(move(code)));
 	ExpandedType typeConcrete = program->root->findType("Concrete");
 
 	llvm::Type* raw = program->llvm->toLLVMType(typeConcrete);
 }
 
 TEST(Types, ArrayOfExternal1){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
 	Parser parser(&scanner);
 	parser.Parse();
 
 	AST& ast = parser.root;
 	CodeScope* body = ast.findFunction("test")->getEntryScope();
 
 	Symbol symb = body->findSymbol("childrenRaw");
 
     const TypeAnnotation& t = CodeScope::findDefinition(symb);
     const ExpandedType& t2 = ast.expandType(t);
     EXPECT_EQ(t2->__operator, TypeOperator::ARRAY);
 }
 
 TEST(Types, ExternType1){
 	FILE* input = fopen("scripts/testspass/Containers_Implementation_LinkedList1.xreate","r");
 	assert(input != nullptr);
 
 	Scanner scanner(input);
 	Parser parser(&scanner);
 	parser.Parse();
 
 	AST& ast = parser.root;
 	CodeScope* body = ast.findFunction("test")->getEntryScope();
 
 	Symbol symbTree = body->findSymbol("tree");
 
     const TypeAnnotation& t = CodeScope::findDefinition(symbTree);
     const ExpandedType& t2 = ast.expandType(t);
     EXPECT_EQ(t2->__operator, TypeOperator::CUSTOM);
 }
 
+//TEST string type
diff --git a/cpp/tests/upcoming.cpp b/cpp/tests/upcoming.cpp
new file mode 100644
index 0000000..fc248d1
--- /dev/null
+++ b/cpp/tests/upcoming.cpp
@@ -0,0 +1,5 @@
+#include "gtest/gtest.h"
+
+TEST(AST, DISABLED_functionModification){
+    //x = find single (...), where single - is a modification sign of a base function 'find'
+}
diff --git a/cpp/tests/xml.cpp b/cpp/tests/xml.cpp
new file mode 100644
index 0000000..cb62100
--- /dev/null
+++ b/cpp/tests/xml.cpp
@@ -0,0 +1,31 @@
+#include "passmanager.h"
+#include "Scanner.h"
+
+#include "gtest/gtest.h"
+
+using namespace xreate;
+
+TEST(Xml, Main){
+    FILE* input = fopen("scripts/xml/input.xreate", "r");
+    assert(input != nullptr);
+
+    Scanner scanner(input);
+    PassManager*  program  = PassManager::prepareForCode(scanner);
+
+    void* mainPtr = program->run();
+    int (*main)() = (int (*)())(intptr_t)mainPtr;
+
+    int answer = main();
+}
+
+TEST(Xml, DISABLED_AliasTuple){
+
+}
+
+TEST(Xml, DISABLED_FoldProtoEnhanced){
+
+}
+
+TEST(Xml, DISABLED_TransfucPropagation){
+
+}
diff --git a/project/subsystems.graphmlz b/project/subsystems.graphmlz
deleted file mode 100644
index 571f723..0000000
Binary files a/project/subsystems.graphmlz and /dev/null differ
diff --git a/scripts/environment-tests/current b/scripts/environment-tests/current
new file mode 100644
index 0000000..ba337ec
--- /dev/null
+++ b/scripts/environment-tests/current
@@ -0,0 +1,8 @@
+// install cmake
+// install llvm
+// install gcc
+// install gtest
+
+function():: testEnvironment(exists(gcc)){
+	exec("gcc -v") :: expectNoErrors.
+}
diff --git a/scripts/environment-tests/xreate-environment b/scripts/environment-tests/xreate-environment
new file mode 100644
index 0000000..f7428c8
--- /dev/null
+++ b/scripts/environment-tests/xreate-environment
@@ -0,0 +1,60 @@
+// install cmake
+// install llvm
+// install gcc
+// install gtest
+
+function():: TestEnvironment(exists(gcc)){
+	exec("gcc -v") :: ExpectNoErrors; log("Check gcc").
+}
+
+function():: provide(gcc) {
+	exec("sudo apt-get install gcc"):: log("[GCC] Installation").
+}
+
+function():: TestEnvironment(exists(cmake)){
+	exec("cmake /V"):: ExpectNoErrors; log("Check cmake").
+}
+
+function():: provide(cmake) {
+	exec("sudo apt-get install cmake"):: log("[CMake] Installation").
+}
+
+function():: TestEnvironment(exists(subversion)){
+	exec("svn --version"):: ExpectNoErrors; log("Check svn").
+}
+
+function():: provide(subversion) {
+	exec("sudo apt-get install subversion"):: log("[Subversion] Installation").
+}
+
+function():: TestEnvironment(exists(scons)){
+	exec("scons -v"):: ExpectNoErrors; log("Check scons").
+}
+
+function():: provide(scons) {
+	exec("sudo apt-get install scons"):: log("[Scons] Installation").
+}
+
+function():: TestEnvironment(exists(bison)){
+	exec("bison --version"):: ExpectNoErrors; log("Check bison").
+}
+
+function():: provide(bison) {
+	exec("sudo apt-get install bison"):: log("[Bison] Installation").
+}
+
+//FEATURE dependent packages: Subversion
+function():: provide(gringo)
+{
+	exec("cd /opt"). //FEATURE states: dir("/opt")
+	exec("svn://svn.code.sf.net/p/potassco/code/trunk")
+		:: log("[Potassco] cloning latest version");
+			require(svn); require(rights("/opt", WRITE)). //"sudo chown -R user ./potassco"
+
+		//
+	exec("scons --build-dir=release"):: require(scons)
+}
+
+function()::{
+
+}
diff --git a/scripts/function-modifications/control-context.lp b/scripts/function-modifications/control-context.lp
new file mode 100644
index 0000000..22d3247
--- /dev/null
+++ b/scripts/function-modifications/control-context.lp
@@ -0,0 +1 @@
+function_mod(func1, mod1):-  %context condition
diff --git a/scripts/function-modifications/current b/scripts/function-modifications/current
new file mode 100644
index 0000000..1cbf57d
--- /dev/null
+++ b/scripts/function-modifications/current
@@ -0,0 +1,92 @@
+interface(extern-c){						
+xml2 = library:: pkgconfig(\"libxml-2.0\") 
+	[\"libxml/tree.h\"].
+
+include [xml2].
+}
+
+
+a = function()::int; 
+	enrty; bug(2530)
+{
+	<entry; bug(2530)>
+	
+}
+
+interface(cfg){
+	context operator map:: hfgfgfgf
+	context function a:: optimization: mem
+}
+
+function a :: entry;
+}
+
+a<int>::int.
+
+
+result = fold(vector->el, zero -> acc) {
+	
+}
+
+
+main:: entry; bug(2711); unsafe; permissions(usb_access)  = function(a::int, b::int)::string; {
+}
+
+a = function()<int>
+context
+main = function  (a::xxs, b::fefe -> r::fdfd):: fdfdfd case attr x:: AA, BB 
+	{
+		<optimization: mem>
+		context::  {
+			frdkfkfe
+		}
+		
+	}
+
+	case attr <optimize: mem>
+	<AAA, BBB> {
+		a() + b().
+	}
+
+	{
+		<AAA, BBB>
+		
+	}
+
+	context:: optimization: mem; warnings: off 
+	{
+		
+	}					{
+
+	case <odd> {
+		result = a() + b() :: <odd>
+	}
+
+	case a::odd {
+		
+	}
+
+	context<odd; asasa>
+	result = a() + b() ::  odd.
+
+	result = a()::odd + b().
+}
+
+
+a = function() {}{}{}{} {}{}{}{}{}{}{}{}{}{}{}{}{}
+
+argument
+function
+result
+function context
+
+annotation several values, annotation sole value;
+function xxs;fdfdfd;fdfd, fdfd;qwqwq;trtrt;iui, aaa;bbb -> qqq; www
+	:: entry
+	<warnings: off>
+	case <optimization: mem> {
+		<warnings: important>
+		a() + b()		
+	}
+
+	
diff --git a/scripts/function-modifications/data-context.lp b/scripts/function-modifications/data-context.lp
new file mode 100644
index 0000000..8b13789
--- /dev/null
+++ b/scripts/function-modifications/data-context.lp
@@ -0,0 +1 @@
+
diff --git a/scripts/input.xreate b/scripts/input.xreate
deleted file mode 100644
index bb95705..0000000
--- a/scripts/input.xreate
+++ /dev/null
@@ -1,106 +0,0 @@
-
-
-/* local scope doc ptr */
-
-
-XmlNode = type alias {
-        tag:: string,
-       /* attrs:: [string],*/
-        content:: string
-}.
-
-interface(extern-c){
-  xml2 = library:: pkgconfig("libxml-2.0").
-  
-  include {
-    xml2 = ["libxml/tree.h", "string.h"]
-  }.
-}       
-
-Tree = type Tree(Leaf) [Leaf, [Tree(Leaf)]].
-XmlTree = type alias Tree(XmlNode).
-
-Alias = type alias [String, String].
-AliasList = type alias [Alias].
-
-
-classesAliasQuery  = function(node:: xmlNodePtr):: Alias
-{
-      classesPara = ["pgess1", "pgess2"] :: [String].
-      
-      
-      result = 
-        case default {none}
-      
-        case node[tag] == "style",  class in classesPara, 
-                classAlias = node[attrs, "name"], 
-                class=node[attrs, "parent-style-name"],
-        {
-          [classAlias. class]
-        }.
-        
-      result.
-}
-
-
-dictAliases = function():: AliasList{
-    filename = "project/documentation.fodt" :: string.
-    docRaw = xmlParseFile(filename) :: xmlDocPtr.
-    tree= xmlDocGetRootElement(docRaw) :: xmlNodePtr.
-    
-    nodeStylesRoot = find(tree, "automatic-styles"):: xmlNodePtr.
-    nodesStyles= nodeStylesRoot["xmlChildrenNode"]:: [xmlNodePtr]; containers:linkedlist(next, null).
-    
-    dictAliases = loop fold(nodesStyles->nodeStyle:: xmlNodePtr, []->aliases::[xmlNodePtr]):: [xmlNodePtr] {
-       aliases + classAliasesQuery(nodeStyle).
-    }.
-    
-    dictAliases
-}
-
-test1 = function():: int; entry {
-  dictAliases = dictAliases():: AliasList.
-  
-  count = loop fold(dictAliases->alias::Alias, 0->count::int):: int{
-    aliasName = alias[0]:: String; logging.
-    aliasOrigClass = alias[1]::String; logging.
-    
-    0 + strlen(aliasName) + strlen(aliasOrigClass).
-  }
-  
-  count
-}
-
-/*
-toXmlNode = function (nodeRaw:: xmlNodePtr):: XmlNode
-{
-    {tag = nodeRaw["name"], content=null}
-}
-
-
-children = function (tree:: xmlNodePtr):: XmlTree
-{
-    childrenRaw = tree["xmlChildrenNode"]:: [xmlNodePtr]; containers:linkedlist(next, null).
-     
-    loop map (childrenRaw->childRaw:: xmlNodePtr):: XmlTree {
-      [toXmlNode(childRaw), children(childRaw)]
-    }
-}
-
- 
-document = function (filename:: string):: XmlTree
-{
-  docRaw = xmlParseFile(filename) :: xmlDocPtr.
-  nodeRaw= xmlDocGetRootElement(docRaw) :: xmlNodePtr.
-  
-  [toXmlNode(nodeRaw), children(nodeRaw)]:: XmlTree
-}
-
-*/ 
-
-
-
-
-
-
-
diff --git a/scripts/xml/xml-client.xreate b/scripts/xml/[old] xml-client.xreate
similarity index 63%
rename from scripts/xml/xml-client.xreate
rename to scripts/xml/[old] xml-client.xreate
index dc1b2cb..5ea610f 100644
--- a/scripts/xml/xml-client.xreate
+++ b/scripts/xml/[old] xml-client.xreate	
@@ -1,71 +1,112 @@
 /*
 
 Example of c++ code: 
 
     xmlDocPtr doc;
     xmlNodePtr cur;
     doc = xmlParseFile(docname.c_str());
     if (doc == NULL ) {
         fprintf(stderr,"Document not parsed successfully. \n");
         return;
     }
     cur = xmlDocGetRootElement(doc);
     if (cur == NULL) {
         fprintf(stderr,"empty document\n");
         xmlFreeDoc(doc);
         return;
     }
 
     cur = cur->xmlChildrenNode;
     while (cur != NULL) {
         printf("child: %s\n", cur->name);
 
         cur = cur->next;
     }
     
 */
 
 /*
  
     Default strategies:
       - what to do with unspecified nodes
       
     Node content strategy:
       - send as-is
       - apply transforms (all / named)
       -  ?? skip
       
     Processing order: 
       - dependencies
  
  */
+ 
+ default_filname = "project/documentation.fodt" : string;
+
+/* require ptrvalid */
+/* local scope doc ptr */
+
+XmlNode = type {
+        tag: string; 
+        attrs: [string]; 
+        content: string}.
+        
+Tree = type(Leaf) Tree [Leaf; [Tree(Leaf)]];
+
+XmlTree = Tree(XmlNode);
+
+
+children = function: (tree: xmlNodePtr)->XmlTree
+{
+    childrenRaw = tree[xmlChildrenNode]: [xmlNodePtr], linkedlist(next, null);
+    
+    map (childrenRaw->childRaw: xmlNodePtr) {
+      Tree[childRaw[name] children(childRaw)]
+    }
+}
+
+
+document = function: (filename: string)->XmlTree
+{
+  docRaw = xmlParseFile(docname.c_str()) : xmlDocPtr;
+  nodeRaw= xmlDocGetRootElement(docRaw) : xmlNodePtr;
+  
+  Tree [nodeRaw[name] children(nodeRaw));
+}
+
 
 query = function(tree: XmlTree): [XmlTree]
 {
     children :  context(children) = 
       case default
         []
       
       case (tree[0]: NeedChildren(childrenFilters), ApplyTransform(transFilters))
       {
         loop fold (tree[1]->child: Tree(Leaf) | childrenFilters; []->accum).
             {accum  + traverse(child): cases(transFilters) };
       }
 
     node = 
       case (node.tag == "style:style"; class = node[attrs, "style:name"]; exists(class, ParaKnownClasses))
       {
         [class, node[attrs, "style:display-name"]];
       }
       
       case default
         [] ;
       
       Tree[node children] | node + children
 }
 
+test = function: ()->num
+{
+    data = query(document(default_filename)): [string, string];
+    
+    exists(data, "pgess1").
+}
+
   /*
 traverse = function(trees: [XmlTree]) : [XmlTree]
   loop fold(trees->tree: Tree; []->acc) 
     acc + traverse(tree)
    */
\ No newline at end of file
diff --git a/scripts/xml/all.xreate b/scripts/xml/all.xreate
new file mode 100644
index 0000000..3cd606f
--- /dev/null
+++ b/scripts/xml/all.xreate
@@ -0,0 +1,188 @@
+/*				C++ SECTION
+Example of c++ code: 
+
+    xmlDocPtr doc;
+    xmlNodePtr cur;
+    doc = xmlParseFile(docname.c_str());
+    if (doc == NULL ) {
+        fprintf(stderr,"Document not parsed successfully. \n");
+        return;
+    }
+    cur = xmlDocGetRootElement(doc);
+    if (cur == NULL) {
+        fprintf(stderr,"empty document\n");
+        xmlFreeDoc(doc);
+        return;
+    }
+
+    cur = cur->xmlChildrenNode;
+    while (cur != NULL) {
+        printf("child: %s\n", cur->name);
+
+        cur = cur->next;
+    }
+    
+*/
+
+/*				FEATURES  SECTION
+
+    Default strategies:
+      - what to do with unspecified nodes
+      
+    Node content strategy:
+      - send as-is
+      - apply transforms (all / named)
+      -  ?? skip
+      
+    Processing order: 
+      - dependencies
+
+	Mapping:
+	* tree -> list
+ 
+*/
+
+/*				TODO SECTION
+	-- gather types aliases (tree->list mapping)
+	-- flyweight implementation (doc calculation, for example. based on are there more than one opened document )
+*/
+
+//				REQUIREMENTS SECTION
+/* require ptrvalid */
+/* local scope doc ptr */
+/*	singleton element check(::single) */
+
+XmlAttr = type alias {
+	name:: String,
+	content:: String
+}.
+
+XmlNode = type alias {
+    name:: String,      /* the name of the node, or the entity */
+    children:: [xmlNode], 	/* parent->childs link */
+    content:: String,   /* the content */
+    attributes::[XmlAttr] /* properties list */
+
+			/*
+	void           *_private;	// application data
+    struct _xmlNode *parent;	// child->parent link
+    struct _xmlNode *next;	// next sibling link 
+    struct _xmlNode *prev;	// previous sibling link 
+    struct _xmlDoc  *doc;	// the containing document 
+	unsigned short   line;	// line number 
+			*/
+}.
+
+interface(extern-c){
+  xml2 = library:: pkgconfig("libxml-2.0").
+  
+  include {
+    xml2 = ["libxml/tree.h", "string.h"]
+  }.
+}       
+
+Tree = type Tree(Leaf) [Leaf, [Tree(Leaf)]].
+XmlTree = type alias Tree(XmlNode).
+
+find = .. 
+[xmlNodePtr]; containers:linkedlist(next, null).
+
+
+
+test1 = function():: int; entry {
+  dictAliases = dictAliases():: AliasList.
+  
+  count = loop fold(dictAliases->alias::Alias, 0->count::int):: int{
+    aliasName = alias[0]:: String; logging.
+    aliasOrigClass = alias[1]::String; logging.
+    
+    count + 1
+  }
+  
+  count
+}
+
+/*
+toXmlNode = function (nodeRaw:: xmlNodePtr):: XmlNode
+{
+    {tag = nodeRaw["name"], content=null}
+}
+
+
+children = function (tree:: xmlNodePtr):: XmlTree
+{
+    childrenRaw = tree["xmlChildrenNode"]:: [xmlNodePtr]; containers:linkedlist(next, null).
+     
+    loop map (childrenRaw->childRaw:: xmlNodePtr):: XmlTree {
+      [toXmlNode(childRaw), children(childRaw)]
+    }
+}
+
+ 
+document = function (filename:: string):: XmlTree
+{
+  docRaw = xmlParseFile(filename) :: xmlDocPtr.
+  nodeRaw= xmlDocGetRootElement(docRaw) :: xmlNodePtr.
+  
+  [toXmlNode(nodeRaw), children(nodeRaw)]:: XmlTree
+}
+
+*/ 
+
+Alias = type alias {
+	alias: String,
+	original: String
+}. 
+	
+AliasList = type alias [Alias].
+
+classesPar = ["pgess1", "pgess2"] :: [String].
+classesAliasQuery  = function(node:: xmlNodePtr):: Alias
+{
+      result = 
+        case default {none}
+      
+        case node[tag] == "style",  class in classesPara, 
+                classAlias = node[attrs, "name"], 
+                class=node[attrs, "parent-style-name"],
+        {
+          [classAlias. class]
+        }.
+        
+      result.
+}
+
+
+
+dictAliases = function():: AliasList{
+    filename = "project/documentation.fodt" :: string.
+    docRaw = xmlParseFile(filename) :: xmlDocPtr.
+    tree= xmlDocGetRootElement(docRaw) :: xmlNodePtr.
+    
+    nodeStylesRoot = findNodes(tree, "office:automatic-styles"):: xmlNodePtr; single.
+    nodesStyles= findNodes(nodeStylesRoot, "style:style"):: [xmlNodePtr].
+    
+    nodesChildAliases = filter(nodeStyles){
+		 "style:parent-style-name" in classesPar
+	}
+    
+    dictChildAliases = loop fold(nodesChilds->node:: xmlNodePtr, []->aliases::[Alias]) {
+       aliases + {alias = attr(node, "style:name"), original = attr(node, "style:parent-style-name")}
+    }.
+    
+    nodesDisplayAliases = filter(nodesStyles){
+			"style:parent-style-name" in classesPar
+	}
+	
+    dictDisplayAliases = loop fold(nodesDisplayAliases->node:: xmlNodePtr, []->aliases::[Alias]) {
+       aliases + {alias = attr(node, "style:display-name"), original = attr(node, "style:name")}
+    }.
+    
+    nodesDisplayAliases + dictDisplayAliases
+}
+
+
+
+
+
+
diff --git a/scripts/xml/input.xreate b/scripts/xml/input.xreate
new file mode 100644
index 0000000..e763d7f
--- /dev/null
+++ b/scripts/xml/input.xreate
@@ -0,0 +1,142 @@
+/*				C++ SECTION
+Example of c++ code: 
+
+    xmlDocPtr doc;
+    xmlNodePtr cur;
+    doc = xmlParseFile(docname.c_str());
+    if (doc == NULL ) {
+        fprintf(stderr,"Document not parsed successfully. \n");
+        return;
+    }
+    cur = xmlDocGetRootElement(doc);
+    if (cur == NULL) {
+        fprintf(stderr,"empty document\n");
+        xmlFreeDoc(doc);
+        return;
+    }
+
+    cur = cur->xmlChildrenNode;
+    while (cur != NULL) {
+        printf("child: %s\n", cur->name);
+
+        cur = cur->next;
+    }
+    
+*/
+
+/*				FEATURES  SECTION
+
+    Default strategies:
+      - what to do with unspecified nodes
+      
+    Node content strategy:
+      - send as-is
+      - apply transforms (all / named)
+      -  ?? skip
+      
+    Processing order: 
+      - dependencies
+
+	Mapping:
+	* tree -> list
+ 
+*/
+
+/*				TODO SECTION
+	-- gather types aliases (tree->list mapping)
+	-- flyweight implementation ('doc' field calculation, for example. based on are there more than one opened document )
+*/
+
+//				REQUIREMENTS SECTION
+/* require ptrvalid */
+/* local scope doc ptr */
+/*	singleton element check(::single) */
+
+XmlAttr = type alias {
+	name:: string,
+	content:: string
+}.
+
+XmlNode = type alias {
+    name:: string,      /* the name of the node, or the entity */
+    
+    content:: string,   /* the content */
+    attributes::[XmlAttr] /* properties list */
+
+			/*
+	children:: [xmlNode], 	// parent->childs link
+ 
+	void           *_private;	// application data
+    struct _xmlNode *parent;	// child->parent link
+    struct _xmlNode *next;	// next sibling link 
+    struct _xmlNode *prev;	// previous sibling link 
+    struct _xmlDoc  *doc;	// the containing document 
+	unsigned short   line;	// line number 
+			*/
+}.
+
+interface(extern-c){
+  xml2 = library:: pkgconfig("libxml-2.0").
+  
+  include {
+    xml2 = ["libxml/tree.h", "string.h"]
+  }.
+}       
+
+Tree = type Tree(Leaf) [Leaf, [Tree(Leaf)]].
+XmlTree = type alias Tree(XmlNode).
+
+toXmlNode = function (nodeRaw:: xmlNodePtr):: XmlNode
+{
+	propertiesRaw = nodeRaw["properties"]:: [xmlAttrPtr]; containers:linkedlist(next, null).
+	properties = loop map(propertiesRaw -> property::xmlAttrPtr)::[XmlAttr]{
+		{name=property["name"], content=property["children", "content"]}
+	}.
+	
+    {name = nodeRaw["name"], 
+	 content=nodeRaw["content"], 
+	 attributes=properties}
+}
+
+children = function(nodeRaw::xmlDocPtr)::[XmlTree] {
+	childrenRaw = nodeRaw["children"]:: [xmlDocPtr]; containers:linkedlist(next, null).
+	
+	children = loop map(childrenRaw->child:: xmlDocPtr) :: [XmlTree]{
+		[toXmlNode(child), children(child)]
+	}.
+	
+	children
+}
+
+document = function (filename:: string):: XmlTree
+{
+  docRaw = xmlParseFile(filename) :: xmlDocPtr.
+  nodeRaw= xmlDocGetRootElement(docRaw) :: xmlNodePtr.
+  
+  [toXmlNode(nodeRaw), children(nodeRaw)]:: XmlTree
+}
+
+traverse = function(tree:: XmlTree) :: [XmlNode] {
+	  listOfNodes = loop fold(tree -> node:: XmlTree, []->acc:: [XmlNode]):: [XmlNode]{
+		  acc + node[0] + traverse(node[1]):: [XmlNode]
+	  }.
+
+	listOfNodes
+}
+
+test1 = function():: int; entry {
+	filename = "project/documentation.fodt" :: string.
+	
+	root = document(filename):: XmlTree.
+	nodesAll = traverse(root):: [XmlNode].
+	
+	result = loop fold(nodesAll->node:: XmlNode, 0->count::int):: int{
+		count + if (0==strcmp(node["name"], "section")) :: int {
+			1
+		} else {
+			0
+		}
+	}.
+	
+	result
+}
diff --git a/scripts/xml/xml-backup.xreate b/scripts/xml/xml-backup.xreate
deleted file mode 100644
index 7fe9246..0000000
--- a/scripts/xml/xml-backup.xreate
+++ /dev/null
@@ -1,65 +0,0 @@
-default_filname = "project/documentation.fodt" : string;
-
-/* require ptrvalid */
-/* local scope doc ptr */
-
-XmlNode = type {
-        tag: string; 
-        attrs: [string]; 
-        content: string}.
-        
-Tree = type(Leaf) Tree [Leaf; [Tree(Leaf)]];
-
-XmlTree = Tree(XmlNode);
-
-
-children = function: (tree: xmlNodePtr)->XmlTree
-{
-    childrenRaw = tree[xmlChildrenNode]: [xmlNodePtr], linkedlist(next, null);
-    
-    map (childrenRaw->childRaw: xmlNodePtr) {
-      Tree[childRaw[name] children(childRaw)]
-    }
-}
-
-
-document = function: (filename: string)->XmlTree
-{
-  docRaw = xmlParseFile(docname.c_str()) : xmlDocPtr;
-  nodeRaw= xmlDocGetRootElement(docRaw) : xmlNodePtr;
-  
-  Tree [nodeRaw[name] children(nodeRaw));
-}
-
-
-query = function: (tree: XmlTree) [string, string]
-{
-    children :  context(children) = 
-      case default
-        []
-      
-      case (tree[0]: NeedChildren(childrenFilters), ApplyTransform(transFilters))
-      {
-        loop fold (tree[1]->child: Tree(Leaf) | childrenFilters; []->accum).
-            {accum  + traverse(child): cases(transFilters) };
-      }
-
-    node = 
-      case (node.tag == "style:style"; class = node[attrs, "style:name"]; exists(class, ParaKnownClasses))
-      {
-        [class, node[attrs, "style:display-name"]];
-      }
-      
-      case default
-        [] ;
-      
-      node + children;
-}
-
-
-test = function: ()->num
-{
-    data = query(document(default_filename)): [string, string];
-    
-    exists(data, "pgess1").
-}
diff --git a/scripts/xml/xml-query.xreate b/scripts/xml/xml-query.xreate
deleted file mode 100644
index 60a330e..0000000
--- a/scripts/xml/xml-query.xreate
+++ /dev/null
@@ -1,38 +0,0 @@
-XmlNode = type {
-        tag: string; 
-        attrs: [string]; 
-        content: string}.
-        
-Tree = type(Leaf) Tree [Leaf; [Tree(Leaf)]].
-
-XmlTree = Tree(XmlNode).
-
-query = function(tree: XmlTree): [XmlTree]
-{
-    children :  context(children) = 
-      case default
-        []
-      
-      case (tree[0]: NeedChildren(childrenFilters), ApplyTransform(transFilters))
-      {
-        loop fold (tree[1]->child: Tree(Leaf) | childrenFilters; []->accum).
-            {accum  + traverse(child): cases(transFilters) };
-      }
-
-    node = 
-      case (node.tag == "style:style"; class = node[attrs, "style:name"]; exists(class, ParaKnownClasses))
-      {
-        [class, node[attrs, "style:display-name"]];
-      }
-      
-      case default
-        [] ;
-      
-      Tree[node children] | node + children
-}
-
-  /*
-traverse = function(trees: [XmlTree]) : [XmlTree]
-  loop fold(trees->tree: Tree; []->acc) 
-    acc + traverse(tree)
-   */
\ No newline at end of file
diff --git a/tools/testrender/CMakeLists.txt b/tools/testrender/CMakeLists.txt
index 690ae5f..b87e502 100644
--- a/tools/testrender/CMakeLists.txt
+++ b/tools/testrender/CMakeLists.txt
@@ -1,5 +1,10 @@
 project(testrender)
 cmake_minimum_required(VERSION 2.8)
+INCLUDE_DIRECTORIES("/usr/include/libxml2")
+set(CMAKE_BUILD_TYPE Debug)
+set(CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG} -g -Wall -std=c++11")
+
 aux_source_directory(. SRC_LIST)
 add_executable(${PROJECT_NAME} ${SRC_LIST})
+target_link_libraries(${PROJECT_NAME} -lxml2)
 
diff --git a/tools/testrender/main.cpp b/tools/testrender/main.cpp
index 5f5419b..d86ce29 100644
--- a/tools/testrender/main.cpp
+++ b/tools/testrender/main.cpp
@@ -1,10 +1,134 @@
 #include <iostream>
+#include <stdlib.h>
+#include <boost/format.hpp>
+#include <string>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/xpath.h>
+#include <libxml/xpathInternals.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <boost/algorithm/string/split.hpp>
 
+#include <map>
+#include <list>
+#include <set>
 using namespace std;
 
+char* pathTestsOutput = "/tmp/xreate-tests-output-XXXXXX";
+const string& pathComponentsGraph = "/private/prg/code/xreate/project/subsystems.graphml";
+
+map<string, bool> tests;
+set<string> testsUnused;
+
+void runTests(){
+    //mkstemp(pathTestsOutput);
+    const string &cmm_export = string("export GTEST_OUTPUT=\"xml:")+ pathTestsOutput +"\"";
+    const string &cmm_chdir = "cd /private/prg/code/xreate/";
+    const string &cmm_runtest = "exec build/xreate";
+
+    const string& comm = boost::str(boost::format("(%1% && %2% && %3%)") % cmm_export % cmm_chdir % cmm_runtest);
+    system(comm.c_str());
+}
+
+void parseTestsOutput(){
+    const string& queryTestCases = "//testcase[@status='run']";
+
+    xmlDocPtr doc = xmlParseFile(pathTestsOutput);
+    xmlXPathContextPtr context = xmlXPathNewContext(doc);
+    xmlXPathObjectPtr testcases = xmlXPathEvalExpression((xmlChar*) queryTestCases.c_str(), context);
+
+    for (int caseId = 0; caseId < testcases->nodesetval->nodeNr; ++caseId) {
+        xmlNodePtr testcase = testcases->nodesetval->nodeTab[caseId];
+
+        string nameTestSuite((const char *) xmlGetProp(testcase->parent, (const xmlChar*)"name"));
+        string nameTestCase((const char *) xmlGetProp(testcase, (const xmlChar*)"name"));
+        bool flagSuccess = (testcase->children)? false: true;
+
+        string testName = nameTestSuite+":"+nameTestCase;
+        tests.emplace(testName, flagSuccess);
+        testsUnused.insert(testName);
+    }
+}
+
+string getTestsResultForComponent(const string& signature){
+    list<string> componentParts;
+    boost::split(componentParts, signature, [](const char& a){return a==',';});
+
+    int resNeg = 0; int resPos = 0; bool flagTestsFound = false;
+    for(auto test: tests){
+        for(const string& signature: componentParts){
+            if (boost::icontains(test.first, signature)){
+                if (test.second){
+                    resPos ++;
+                } else {
+                    resNeg--;
+                }
+
+                flagTestsFound = true;
+                testsUnused.erase(test.first);
+                break;
+            }
+        }
+    }
+
+    if (!flagTestsFound){
+        cout << "Warning: No tests for "<<signature << endl;
+    }
+
+    return (resNeg!=0)? to_string(resNeg) : to_string(resPos);
+}
+
+void parseComponentsGraph(){
+    const string& queryNode = "//a:node[a:data[@key=\"d4\"]]";
+    const string& queryTestResults = "a:data[@key='d5']";
+    const string& queryTestSignature = "a:data[@key='d4']";
+
+    xmlDocPtr doc = xmlParseFile(pathComponentsGraph.c_str());
+    xmlNodePtr root = xmlDocGetRootElement(doc);
+
+    xmlXPathContextPtr context = xmlXPathNewContext(doc);
+    xmlXPathRegisterNs(context, (xmlChar*) "a", (xmlChar*) "http://graphml.graphdrawing.org/xmlns");
+    xmlXPathObjectPtr setComponents = xmlXPathEvalExpression((xmlChar*) queryNode.c_str(), context);
+
+    for (int nodeId=0; nodeId < setComponents->nodesetval->nodeNr; ++nodeId){
+        xmlNodePtr nodeComponent = setComponents->nodesetval->nodeTab[nodeId];
+        //xmlXPathSetContextNode(node, context);
+        context->node = nodeComponent;
+        xmlXPathObjectPtr setNodeTestSignature = xmlXPathEvalExpression((xmlChar*) queryTestSignature.c_str(), context);
+        assert(setNodeTestSignature->nodesetval->nodeNr==1);
+        char* componentTestsSignature = (char*) xmlNodeGetContent(setNodeTestSignature->nodesetval->nodeTab[0]);
+
+        string componentTestsResult = getTestsResultForComponent(componentTestsSignature);
+
+        xmlXPathObjectPtr setNodeTestResult = xmlXPathEvalExpression((xmlChar*) queryTestResults.c_str(), context);
+
+        if (0 == setNodeTestResult->nodesetval->nodeNr){
+             xmlNodePtr dataTestsResult = xmlNewChild(nodeComponent, NULL, BAD_CAST "data",
+                                                      BAD_CAST componentTestsResult.c_str());
+
+             xmlNewProp(dataTestsResult, BAD_CAST "key", BAD_CAST "d5");
+             continue;
+        }
+        assert(setNodeTestResult->nodesetval->nodeNr == 1);
+        xmlNodePtr dataTestsResult = setNodeTestResult->nodesetval->nodeTab[0];
+        xmlNodeSetContent(dataTestsResult, BAD_CAST componentTestsResult.c_str());
+    }
+
+    xmlSaveFile(pathComponentsGraph.c_str(), doc);
+}
+
+void checkUnusedTests(){
+    for (string test: testsUnused){
+        cout << "Warning: no components use test "<<test << endl;
+    }
+}
+
 int main()
 {
-    cout << "Hello World!" << endl;
+    runTests();
+    parseTestsOutput();
+    parseComponentsGraph();
+    checkUnusedTests();
     return 0;
 }