anchor.diff:              VarString = string:join(ArgsStr,", "),
               MyCall = ?LIN([MyVar,"=","call",decode_type(RetType), LambdaVar, "(", VarString ,")"]),
               {MyVar, [ MyCall | ArgCodeLines ]};
  +
  +    #fix{ closure=Closure } ->
  +        #closure{ lambda = Lambda =  #lambda{ type=Type}} = Closure,
  +        {FunctionName,_} = codegen(Lambda),
  +        StructPointer = compil_table:newTemp(),
  +        ClosureTypeName = "clojure_fix",
  +        ClosureType = "%" ++ ClosureTypeName ++"*",
  +
  +        FixName =  "@fix",
  +        ValueName = "%fix_value",
  +        RetValueName = "%fix_ret",
  +        FixHeader = ?LIN(["define","i32",FixName,"(i32",ValueName,")"]),
  +        FixCall =  ?LIN([RetValueName,"=","call","i32",FunctionName,"(", ClosureType ,StructPointer,
  +                ",","i32",ValueName,")"]),
  +        FixReturn = ?LIN(["ret","i32",RetValueName]),
  +
  +        ArgTypes = [int],
  +        ArgsStr = lists:map( fun({Var, Type}) -> decode_type(Type) ++ " " ++  Var end,
  +            lists:zip(Vars, ArgTypes)),
  +        VarString = string:join(ArgsStr,", "),
  +
  +
  +        FunctionPointer = compil_table:newTemp(),
  +        AllocCode = ?LIN([StructPointer,"=","alloca","%" ++ ClosureTypeName]),
  +        GetFPCode = ?LIN([FunctionPointer,"=","getelementptr",ClosureType,StructPointer++ ",","i32 0,","i32 0"]),
  +        StoFPCode = ?LIN(["store","i32(i32)*", FixName ++ "," ,"i32(i32)*" ++ "*",FunctionPointer]),
  +
  +        Code = ?FUNCTION([ FixHeader, AllocCode, GetFPCode, StoFPCode, FixCall, FixReturn]),
  +        compil_emitter:function(Code),
  +
  +        MyVar = compil_table:newTemp(),
  +        MyCall = ?LIN([MyVar,"=","call",decode_type(RetType), FixName, "(", VarString ,")"]),
  +        {MyVar, [ MyCall | ArgCodeLines ]};
  +
  +
           Other -> % callee must be a closure
               ClType = #typeCl{ lambda=FunType = #typeFun{ arguments=ArgTypes }, captures=CaptureTypes } = extract_type(Other),
               { StructPointer, PrevCodes} = codegen(Other),
  
positive.code:         #name{ name=Primitiv, primitiv=true } ->
              MyVar = compil_table:newTemp(),
              [VarA, VarB] = Vars,
              MyOp = ?LIN([MyVar,"=", decode(Primitiv), decode_type(RetType), VarA,",",VarB]),
              {MyVar, [ MyOp | ArgCodeLines ]};
          #lambda{ type=#typeFun {arguments=ArgTypes} } = Lambda ->
              {LambdaVar, _ } = codegen(Lambda),
  
negative.code: 
      LoadCode = ?LIN([MyVar,"=","load","i32*",Pointer]),
  
      {MyVar, lists:reverse(lists:reverse(CondCodes) ++ [AllocCode, BranchCode] ++
              [LabelTrueCode | lists:reverse(TrueCodes)] ++
              [ StoreTrueCode | [ContinueCode | [LabelFalseCode | lists:reverse(FalseCodes)]]] ++
              [StoreFalseCode, ContinueCode,  LabelContinueCode, LoadCode ])};
  
  
  