anchor.diff:                      let firstGpuArray = first :?> IGpuArray
                       let secondGpuArray = second :?> IGpuArray
                       let sourceLength = firstGpuArray.Length
  -                    let headerStr = headerStr context.Exprs
                       let exprs, paramExprs, values = constantLifting context.Exprs
  +                    let vars = Seq.append paramExprs vars
  +                    let headerStr = headerStr (exprs, paramExprs, values)
                       let valueArgs = (paramExprs, values) ||> Array.zip |> Array.map (fun (paramExpr, value) -> (value, paramExpr.Type)) 
  -                    let exprsStr = exprs
  -                                       |> Seq.map (fun expr -> sprintf' "%s;" (exprToStr expr (Seq.append paramExprs vars)))
  -                                       |> Seq.fold (fun first second -> sprintf' "%s%s%s" first Environment.NewLine second) ""
  -                    let varsStr = vars 
  -                                      |> Seq.filter (fun varExpr -> not (isAnonymousType varExpr.Type))
  -                                      |> Seq.map (fun varExpr -> sprintf' "%s %s;" (typeToStr varExpr.Type) (varExprToStr varExpr vars)) 
  -                                      |> Seq.fold (fun first second -> sprintf' "%s%s%s" first Environment.NewLine second) ""
  +                    let (exprsStr, varsStr) = bodyStr exprs vars
                       let argsStr = argsToStr paramExprs vars
                       match context.ReductionType with
                       | ReductionType.Map ->
  
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
  