anchor.diff:                          sprintf' "exp(%s)" (exprToStr argExpr vars)
                       | MethodCall (objExpr, methodInfo, [firstExpr; secondExpr]) when methodInfo.Name = "Pow" ->
                           sprintf' "powr(%s, %s)" (exprToStr firstExpr vars) (exprToStr secondExpr vars)
  -
  +                    // Expr Call
  +                    | MethodCall (objExpr, methodInfo, [Parameter funcExpr; argExpr]) when typeof<Expression>.IsAssignableFrom(funcExpr.Type) &&
  +                                                                                 methodInfo.Name = "Invoke" ->
  +                        sprintf' "%s(%s)" (varExprToStr funcExpr vars) (exprToStr argExpr vars)
                       | ValueTypeMemberInit (members, bindings) ->
                           let bindingsStr = bindings |> Seq.fold (fun bindingsStr binding -> sprintf' ".%s = %s, %s" binding.Member.Name (exprToStr binding.Expression vars) bindingsStr) ""
                           sprintf' "(%s) { %s }" (typeToStr expr.Type) bindingsStr
  
positive.code:                     |> Seq.map structToStr
                      |> Set.ofSeq
                      |> Seq.fold (fun first second -> sprintf' "%s%s%s" first Environment.NewLine second) ""
                  let structsDefinitionStr (exprs : Expression list) =
                      exprs
                      |> List.collect collectCustomStructs
                      |> customStructsToStr
                  let headerStr (exprs : Expression list) = 
                      sprintf' "%s%s%s" KernelTemplates.openCLExtensions Environment.NewLine (structsDefinitionStr exprs)
                  let constantLifting (exprs : Expression list) = 
                      match exprs with
                      | [] -> ([||], [||], [||])
                      | _ ->
                          let expr, paramExprs, objs = ConstantLiftingTransformer.apply (block [] exprs) 
                          ((expr :?> BlockExpression).Expressions.ToArray(), paramExprs, objs)
                  let argsToStr (argParamExprs : ParameterExpression[]) (paramExprs : seq<ParameterExpression>) = 
                      (argParamExprs, "") 
                      ||> Array.foldBack (fun paramExpr result -> sprintf' "%s %s, %s" (typeToStr paramExpr.Type) (varExprToStr paramExpr paramExprs) result) 
  
  
negative.code:                 let varExprToStr (varExpr : ParameterExpression) (vars : seq<ParameterExpression>) = 
                      let index = vars |> Seq.findIndex (fun varExpr' -> varExpr = varExpr')
                      sprintf' "%s%d" (varExpr.ToString()) index
                  let constantLifting (exprs : Expression list) = 
                      match exprs with
                      | [] -> ([||], [||], [||])
                      | _ ->
                          let expr, paramExprs, objs = ConstantLiftingTransformer.apply (block [] exprs) 
                          ((expr :?> BlockExpression).Expressions.ToArray(), paramExprs, objs)
                  let isCustomStruct (t : Type) = t.IsValueType && not t.IsPrimitive
                  let structToStr (t : Type) = 
                      let fieldsStr = 
  