anchor.diff:                      |> Seq.map structToStr
                       |> Set.ofSeq
                       |> Seq.fold (fun first second -> sprintf' "%s%s%s" first Environment.NewLine second) ""
  -                let structsDefinitionStr (exprs : Expression list) =
  +                let structsDefinitionStr (exprs : seq<Expression>) =
                       exprs
  -                    |> List.collect collectCustomStructs
  +                    |> Seq.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>) = 
  +                    let argParamExprs = argParamExprs |> Array.filter (fun paramExpr -> not <| typeof<Expression>.IsAssignableFrom(paramExpr.Type))
                       (argParamExprs, "") 
                       ||> Array.foldBack (fun paramExpr result -> sprintf' "%s %s, %s" (typeToStr paramExpr.Type) (varExprToStr paramExpr paramExprs) result) 
   
  
positive.code:                 let varExprToStr (varExpr : ParameterExpression) (vars : seq<ParameterExpression>) = 
                      let index = vars |> Seq.findIndex (fun varExpr' -> varExpr = varExpr')
                      sprintf' "%s%d" (varExpr.ToString()) index
                  
                  let isCustomStruct (t : Type) = t.IsValueType && not t.IsPrimitive
                  let structToStr (t : Type) = 
                      let fieldsStr = 
  
negative.code:                         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
  