anchor.diff:          printfn "Kernel: %A" kernel
           printfn "Kernel.SetArguments: %A" kernel.SetArguments
   
  +        let _1d = new _1D(a1.Length,1)
  +        (kernel.SetArguments ()) _1d m1
  +
  +        processor1.Post(Msg.CreateRunMsg(Run<_,_>(kernel)))
  +
           //This code is unsafe because there is no synchronization between processors
           //It is just to show that we can share buffers between queues on the same device
           let res1 = processor2.PostAndReply(fun ch -> Msg.CreateToHostMsg(ToHost<_>(m1, res1, ch)))
  
positive.code:                             !args |> Array.iteri (fun i x -> setupArgument i x)
                          @@>
                      arr
              let res = <@ %%(go qExpr []):'TRange ->'a @>.Compile()
  
              res
          getStarterFunction srcLambda
      member this.SetArguments = argsSetupFunction
      member this.ClKernel = kernel
      member this.Range = !range :> Brahma.OpenCL.INDRangeDimension
  
  
negative.code:         then raise (new CLException(error))
  
      let range = ref Unchecked.defaultof<'TRange>
      let argsSetupFunction = ()
  
      member this.SetArguments<'t> () =
          let args = ref [||]
          let getStarterFunction qExpr =
              let rec go expr vars =
                  match expr with
                  | Patterns.Lambda (v, body) ->
                      printfn "Type: %A" v.Type.IsArray
                      let v =
                          if v.Type.IsArray
                          then
                              printfn "Type is = %A" v.Type
                              printfn "Type params = %A" (v.Type.GetElementType())
                              let vName = v.Name
                              let vType = typedefof<GpuArray<_>>.MakeGenericType(v.Type.GetElementType())
                              Var(vName, vType, false)
                          else v
                      Expr.Lambda(v, go body (v::vars))
                  | e ->
                      let arr =
  