anchor.diff:          let mutable bderivative = b.zeroLike()
           if not aConst then
               // propagate to a
  -            aderivative <- a.zerosLike()
               let bFlipped = b.flip([|2;3|])
  +            let mutable ad = a.zeroLike()
               for k=0 to outputChannels-1 do
                   let b = bFlipped.[k].view([|inputChannels; 1; kernelHeight; kernelWidth|])
  -                let dBounds = array2D [[0; batchSize-1; 1]; [k; k; 1]; [0; cderivative.shape.[2]-1; 1]; [0; cderivative.shape.[3]-1; 1]]
  +                let dBounds = array2D [[0; batchSize-1; 0]; [k; k; 0]; [0; cderivative.shape.[2]-1; 0]; [0; cderivative.shape.[3]-1; 0]]
                   let d = cderivative.GetSlice(dBounds).view([|batchSize; 1; cderivative.shape.[2]; cderivative.shape.[3]|])
  -                let mutable ad : Tensor = d.conv2d(b, paddings=[|kernelHeight-1; kernelWidth-1|])
  -                if paddings.[0] > 0 || paddings.[1] > 0 then
  -                    let adBounds = array2D [[0; batchSize-1; 1]; 
  -                                           [0; inputChannels-1; 1]; 
  -                                           [paddings.[0]; paddings.[0] + inputHeight - 1; 1]; 
  -                                           [paddings.[1]; paddings.[1] + inputWidth - 1; 1]]
  -                    ad <- ad.GetSlice(adBounds)
  -                    ad <- ad.view([|batchSize; inputChannels; inputHeight; inputWidth|])
  -                aderivative <- aderivative.addSlice([|0; 0; 0; 0|], ad)
  +                ad <- ad + d.conv2d(b, paddings=[|kernelHeight-1; kernelWidth-1|])
  +            if paddings.[0] > 0 || paddings.[1] > 0 then
  +                let adBounds = array2D [[0; batchSize-1; 0]; 
  +                                       [0; inputChannels-1; 0]; 
  +                                       [paddings.[0]; paddings.[0] + inputHeight - 1; 0]; 
  +                                       [paddings.[1]; paddings.[1] + inputWidth - 1; 0]]
  +                ad <- ad.GetSlice(adBounds)
  +                ad <- ad.view([|batchSize; inputChannels; inputHeight; inputWidth|])
  +            aderivative <- a.zerosLike().addSlice([|0; 0; 0; 0|], ad)
           if not bConst then
               // propagate to b
               bderivative <- b.zerosLike()
  
positive.code:     /// <param name="shape">The desired shape of returned tensor.</param>
      member a.view(shape:seq<int>) =
          let shape = shape |> Shape.create |> Shape.complete a.nelement  // Handles -1 semantics
          Shape.checkCanView a.shape shape
          let inline fRaw(a:RawTensor) = a.ViewT(shape)
          let inline fTensor(a:Tensor) = a.view(shape)
  
negative.code:         let mutable bderivative = b.zeroLike()
          if not aConst then
              // propagate to a
              // aderivative <- a.zerosLike()
              let bFlipped = b.flip([|2;3;4|])
              let mutable ad = a.zeroLike()
              for k=0 to outputChannels-1 do
                  let b = bFlipped.[k].view([|inputChannels; 1; kernelDepth; kernelHeight; kernelWidth|])
                  let dBounds = array2D [[0; batchSize-1; 0]; [k; k; 0]; [0; cderivative.shape.[2]-1; 0]; [0; cderivative.shape.[3]-1; 0]; [0; cderivative.shape.[4]-1; 0]]
                  let d = cderivative.GetSlice(dBounds).view([|batchSize; 1; cderivative.shape.[2]; cderivative.shape.[3]; cderivative.shape.[4]|])
                  ad <- ad + d.conv3d(b, paddings=[|kernelDepth-1; kernelHeight-1; kernelWidth-1|])
              if paddings.[0] > 0 || paddings.[1] > 0 || paddings.[2] > 0 then
                  let adBounds = array2D [[0; batchSize-1; 0]; 
                                         [0; inputChannels-1; 0]; 
                                         [paddings.[0]; paddings.[0] + inputDepth - 1; 0]; 
                                         [paddings.[1]; paddings.[1] + inputHeight - 1; 0];
                                         [paddings.[2]; paddings.[2] + inputWidth - 1; 0]]
                  ad <- ad.GetSlice(adBounds)
                  ad <- ad.view([|batchSize; inputChannels; inputDepth; inputHeight; inputWidth|])
              aderivative <- a.zerosLike().addSlice([|0; 0; 0; 0; 0|], ad)
          if not bConst then
              // propagate to b
              bderivative <- b.zerosLike()
  