anchor.diff:          let mutable c = 0
           for i in 0 .. t.Dim - 1 do
               if shape.[i] = 1 && (dim = -1 || i = dim) then 
  -                res <- res.Squeeze(int64 c)
  +                res <- res.squeeze(int64 c)
               else   
                   c <- c + 1
           t.MakeLike(res, shape=newShape)
   
       override t.UnsqueezeT(dim) = 
           let outputShape = Shape.checkCanUnsqueeze dim t.Shape
  -        t.MakeLike(tt.Unsqueeze(int64 dim), shape=outputShape)
  +        t.MakeLike(tt.unsqueeze(int64 dim), shape=outputShape)
   
       override t.FlipT(dims:int[]) = 
           // "flip_cuda" not implemented for 'Bool'"
           let result =
               if dtype = Dtype.Bool then 
  -                tt.ToType(ScalarType.Byte).Flip(int64s dims).ToType(ScalarType.Bool)
  +                tt.to_type(ScalarType.Byte).flip(int64s dims).to_type(ScalarType.Bool)
               elif dtype = Dtype.Float16 || dtype = Dtype.BFloat16  then 
  -                tt.ToType(ScalarType.Float32).Flip(int64s dims).ToType(toTorchType dtype)
  +                tt.to_type(ScalarType.Float32).flip(int64s dims).to_type(toTorchType dtype)
               else
  -                tt.Flip(int64s dims)
  +                tt.flip(int64s dims)
           t.MakeLike(result)
   
       override t.DilateT(dilations:int[]) = 
  
positive.code:         
          // TODO: consider switching to the torch::nn module for MaxUnpool2d
  
          let resultt = tt.MaxUnpool2D(indices.TorchTensor, int64s outputSize)
          t1.MakeLike(resultt, shape=outputShape)
  
      override t1.MaxUnpool3D(indices, outputSize) = 
  
negative.code:     override _.StackTs(tensors, dim) =
          let tts, shapes = tensors |> Array.map (fun t -> (t :?> TorchRawTensor).TorchTensor, t.Shape) |> Array.unzip
          let _n, _shape1, _shape2, newShape = Shape.checkCanStack shapes dim
          let result = tts.stack(int64 dim)
          (tensors.[0] :?> TorchRawTensor).MakeLike(result, newShape)
  
      override t.UnstackT(dim) = 
          let shape = t.Shape
          let _shape1, _shape2, unstackedShape = Shape.checkCanUnstack shape dim
          let results = tt.unbind(dim)
          results |> Array.map (fun rvalues -> t.MakeLike(rvalues, shape=unstackedShape))
  
      override t.CatTs(tensors, dim) = 
          let values, shapes = tensors |> Array.map (fun t -> t.TorchTensor, t.Shape) |> Array.unzip
          let _n, _shape1, _m2, _shape3, outShape = Shape.checkCanCat shapes dim
          let result = values.cat(int64 dim)
          t.MakeLike(result, outShape)
  
      override t.SplitT(sizes, dim) =
          let shape = t.Shape
          let outShapes = Shape.checkCanSplit shape sizes dim
          let results = tt.split_with_sizes(int64s sizes, dim)
          (results, outShapes) ||> Array.map2 (fun rvalues outShape -> 
              t.MakeLike(rvalues, shape=outShape))
  
      override t.PermuteT(permutation) =
          let _, newShape = Shape.checkCanPermute t.Shape permutation
          let result = tt.permute(int64s permutation)
          t.MakeLike(result, shape=newShape)
  
      override t.TransposeT(dim0, dim1) =
          Shape.checkCanTranspose t.Shape dim0 dim1
          let result = tt.transpose(int64 dim0, int64 dim1)
          let shape = result.shape |> Array.map int32
          t.MakeLike(result, shape=shape)
  
      override t.TransposeT2() =
          Shape.checkCanTranspose2d t.Dim
          let newShape = Shape.computeTranspose2d t.Shape
          let result = tt.t()
          t.MakeLike(result, shape=newShape)
  
      override t.SqueezeT(dim) = 
  